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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
b169d802413a49c5701484e433d5ebcb7dc9236327dab63a3b93ee60e9392c50
| 36,569 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x9bdf81e6066d32764b7e75a1b5577237e06d9364.sol
| 9,250 | 35,661 |
pragma solidity =0.6.4;
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 MUSystem{
using SafeMath for uint;
string public constant name="Mutual Uniting System";
string public constant symbol="MUS";
uint public constant decimals=14;
uint public totalSupply;
address payable private creatorOwner;
mapping (address => uint) balances;
struct User{
uint UserTotalAmtWithdrawalCurrentPack;
uint UserWithdrawalFromFirstRefunded;
uint UserTotalAmtDepositCurrentPack;
uint UserAmtDepositCurrentPackTRUE;
uint UserWithdrawalFromDisparity;
uint UserTotalAmtWithdrawal;
uint UserSellTokenPackNum;
bool UserBuyTokenPrevPack;
uint UserTotalAmtDeposit;
uint UserBuyTokenPackNum;
uint UserBuyFirstPack;
uint UserBuyFirstDate;
uint UserContinued;
uint UserFirstAmt;
uint UserSellDate;
uint UserBuyDate;
uint UserCycle;
}
mapping (address => User) users;
struct DepositTemp{
address payable useraddress;
uint p;
uint bonus;
uint userAmt;
uint amtToSend;
uint bonusAmount;
uint userBuyDate;
uint userSellDate;
uint userFirstAmt;
uint userContinued;
uint userAmtToStore;
uint availableTokens;
uint userTokenObtain;
uint userBuyFirstPack;
uint userBuyFirstDate;
uint currentPackNumber;
uint amtForfirstRefund;
uint userBuyTokenPackNum;
uint userTotalAmtDeposit;
uint bonusAmountRefunded;
bool userBuyTokenPrevPack;
uint currentPackStartDate;
uint userAmtOverloadToSend;
uint currentPackTokenPriceSellout;
uint userAmtDepositCurrentPackTRUE;
uint userTotalAmtDepositCurrentPack;
}
struct WithdrawTemp{
address payable useraddress;
uint userTotalAmtWithdrawalCurrentPack;
uint userTokensReturnAboveCurrentPack;
uint userWithdrawalFromFirstRefunded;
uint userTotalAmtDepositCurrentPack;
uint userAmtDepositCurrentPackTRUE;
uint userTokensReturnToCurrentPack;
uint currentPackTokenPriceSellout;
uint currentPackTokenPriceBuyout;
uint withdrawAmtAboveCurrentPack;
uint userWithdrawalFromDisparity;
uint bonusTokensReturnDecrease;
bool returnTokenInCurrentPack;
uint withdrawAmtToCurrentPack;
uint remainsFromFirstRefunded;
uint overallDisparityAmounts;
uint userTotalAmtWithdrawal;
uint useFromFirstRefunded;
uint remainsFromDisparity;
uint TokensReturnDecrease;
uint currentPackStartDate;
uint userAvailableAmount;
uint currentPackDeposits;
uint currentPackNumber;
uint userBuyFirstPack;
uint userTokensReturn;
uint useFromDisparity;
uint overallRefunded;
uint userSellDate;
uint userFirstAmt;
uint userBuyDate;
uint bonusToSend;
uint withdrawAmt;
uint wAtoStore;
uint thisBal;
uint bonus;
uint diff;
uint dsp;
bool ra;
}
uint private Cycle;
uint private PrevPackCost;
bool private feeTransfered;
uint private NextPackDelta;
uint private NextPackYield;
uint private CurrentPackFee;
uint private RestartModeDate;
uint private CurrentPackCost;
uint private OverallDeposits;
uint private OverallRefunded;
uint private PrevPackTotalAmt;
uint private CurrentPackYield;
uint private CurrentPackDelta;
bool private RestartMode=false;
uint private CurrentPackNumber;
uint private OverallWithdrawals;
uint private CurrentPackRestAmt;
uint private CurrentPackTotalAmt;
uint private CurrentPackDeposits;
uint private CurrentPackStartDate;
uint private CurrentPackTotalToPay;
uint private OverallDisparityAmounts;
uint private PrevPackTokenPriceBuyout;
uint private NextPackTokenPriceBuyout;
uint private PrevPackTokenPriceSellout;
uint private CurrentPackTokenPriceBuyout;
uint private CurrentPackDisparityAmounts;
uint private CurrentPackTokenPriceSellout;
uint private CurrentPackTotalToPayDisparity;
constructor()public payable{
creatorOwner=msg.sender;
CurrentPackNumber=1;
Cycle=0;
mint(5000000000000000);
packSettings(CurrentPackNumber);
}
function packSettings(uint _currentPackNumber)internal{
CurrentPackNumber=_currentPackNumber;
if(_currentPackNumber==1){
CurrentPackTokenPriceSellout=10;
CurrentPackTokenPriceBuyout=10;
CurrentPackCost=50000000000000000;
CurrentPackFee=0;
}
if(_currentPackNumber==2){
PrevPackTotalAmt=CurrentPackCost;
CurrentPackDelta=0;
NextPackTokenPriceBuyout=CurrentPackTokenPriceSellout*110/100;
NextPackYield=NextPackTokenPriceBuyout/CurrentPackTokenPriceSellout;
NextPackDelta=NextPackYield;
CurrentPackTokenPriceSellout=NextPackTokenPriceBuyout+NextPackDelta;
CurrentPackTokenPriceBuyout=CurrentPackTokenPriceSellout;
CurrentPackCost=5000000000000000*CurrentPackTokenPriceSellout;
CurrentPackTotalAmt=CurrentPackCost+PrevPackTotalAmt;
CurrentPackFee=0;
}
if(_currentPackNumber>2){
PrevPackTokenPriceSellout=CurrentPackTokenPriceSellout;
PrevPackTokenPriceBuyout=CurrentPackTokenPriceBuyout;
PrevPackCost=CurrentPackCost;
PrevPackTotalAmt=CurrentPackTotalAmt;
CurrentPackDelta=NextPackDelta;
CurrentPackTokenPriceBuyout=NextPackTokenPriceBuyout;
NextPackTokenPriceBuyout=PrevPackTokenPriceSellout*110;
if(NextPackTokenPriceBuyout<=100){
NextPackTokenPriceBuyout=PrevPackTokenPriceSellout*11/10;
}
if(NextPackTokenPriceBuyout>100){
NextPackTokenPriceBuyout=NextPackTokenPriceBuyout*10**3;
NextPackTokenPriceBuyout=((NextPackTokenPriceBuyout/10000)+5)/10;
}
NextPackYield=NextPackTokenPriceBuyout-PrevPackTokenPriceSellout;
NextPackDelta=NextPackYield*101;
if(NextPackDelta<=100){
NextPackDelta=CurrentPackDelta+(NextPackYield*101/100);
}
if(NextPackDelta>100){
NextPackDelta=NextPackDelta*10**3;
NextPackDelta=((NextPackDelta/10000)+5)/10;
NextPackDelta=CurrentPackDelta+NextPackDelta;
}
CurrentPackTokenPriceSellout=NextPackTokenPriceBuyout+NextPackDelta;
CurrentPackCost=5000000000000000*CurrentPackTokenPriceSellout;
CurrentPackTotalToPay=5000000000000000*CurrentPackTokenPriceBuyout;
CurrentPackTotalAmt=CurrentPackCost+PrevPackTotalAmt-CurrentPackTotalToPay;
CurrentPackFee=PrevPackTotalAmt-CurrentPackTotalToPay-(PrevPackCost*7/10);
}
CurrentPackDisparityAmounts=0;
CurrentPackDeposits=0;
CurrentPackStartDate=now;
emit NextPack(CurrentPackTokenPriceSellout,CurrentPackTokenPriceBuyout);
}
function aboutCurrentPack()public view returns(uint num,uint bal,uint overallRefunded,uint dsp,uint availableTokens,uint availableTokensInPercentage,uint availableAmountToDepositInWei,uint tokenPriceSellout,uint tokenPriceBuyout,uint cycle,uint overallDeposits,uint overallWithdrawals,bool){
if(CurrentPackDeposits+OverallDisparityAmounts>CurrentPackDisparityAmounts+OverallRefunded){
dsp = CurrentPackDeposits+OverallDisparityAmounts-CurrentPackDisparityAmounts-OverallRefunded;
}else{
dsp=0;
}
return(CurrentPackNumber,address(this).balance,OverallRefunded,dsp,balances[address(this)],0,balances[address(this)].mul(CurrentPackTokenPriceSellout),CurrentPackTokenPriceSellout,CurrentPackTokenPriceBuyout,Cycle,OverallDeposits,OverallWithdrawals,RestartMode);
}
function aboutUser()public view returns(uint UserFirstAmt,uint remainsFromFirstRefunded,uint UserContinued,uint userTotalAmtDeposit,uint userTotalAmtWithdrawal,uint userAvailableAmount,uint userAvailableAmount1,uint remainsFromDisparity,uint depCP,uint witCP,uint userCycle,uint wAmtToCurrentPack,uint userBuyFirstDate){
if(users[msg.sender].UserBuyDate>CurrentPackStartDate&&users[msg.sender].UserBuyTokenPackNum==CurrentPackNumber){
wAmtToCurrentPack=users[msg.sender].UserAmtDepositCurrentPackTRUE;
}else{
wAmtToCurrentPack=0;
}
if(users[msg.sender].UserSellDate>CurrentPackStartDate&&users[msg.sender].UserSellTokenPackNum==CurrentPackNumber){
witCP=users[msg.sender].UserTotalAmtWithdrawalCurrentPack;
}else{
witCP=0;
}
if(users[msg.sender].UserBuyDate>CurrentPackStartDate&&users[msg.sender].UserBuyTokenPackNum==CurrentPackNumber){
depCP=users[msg.sender].UserTotalAmtDepositCurrentPack;
}else{
depCP=0;
}
remainsFromFirstRefunded=(users[msg.sender].UserFirstAmt*6/10).sub(users[msg.sender].UserWithdrawalFromFirstRefunded);
remainsFromDisparity=(users[msg.sender].UserFirstAmt*7/10).sub(users[msg.sender].UserWithdrawalFromDisparity);
userAvailableAmount=(balances[msg.sender]-((wAmtToCurrentPack)/CurrentPackTokenPriceSellout))*CurrentPackTokenPriceBuyout+wAmtToCurrentPack;
if(userAvailableAmount>remainsFromDisparity){
userAvailableAmount=userAvailableAmount-remainsFromDisparity;
}else{
userAvailableAmount=0;
}
if (userAvailableAmount<10){
userAvailableAmount=0;
}
uint dsp=0;
if(CurrentPackDeposits+OverallDisparityAmounts>CurrentPackDisparityAmounts+OverallRefunded){
dsp=CurrentPackDeposits+OverallDisparityAmounts-CurrentPackDisparityAmounts-OverallRefunded;
}
if(address(this).balance>dsp){
userAvailableAmount1=address(this).balance-dsp;
}else{
userAvailableAmount1=0;
}
return(users[msg.sender].UserFirstAmt,remainsFromFirstRefunded,users[msg.sender].UserContinued,users[msg.sender].UserTotalAmtDeposit,users[msg.sender].UserTotalAmtWithdrawal,userAvailableAmount,userAvailableAmount1,remainsFromDisparity,depCP,witCP,userCycle,wAmtToCurrentPack,users[msg.sender].UserBuyFirstDate);
}
function nextPack(uint _currentPackNumber)internal{
transferFee();
feeTransfered=false;
CurrentPackNumber=_currentPackNumber+1;
if(_currentPackNumber>0){
mint(5000000000000000);
}
packSettings(CurrentPackNumber);
}
function restart(bool _rm)internal{
if(_rm==true){
if(RestartMode==false){
RestartMode=true;
RestartModeDate=now;
}else{
if(now>RestartModeDate+14*1 days){
Cycle=Cycle+1;
nextPack(0);
RestartMode=false;
}
}
}else{
if(RestartMode==true){
RestartMode=false;
RestartModeDate=0;
}
}
}
function transferFee()internal{
if(CurrentPackNumber>2&&feeTransfered==false&&RestartMode==false){
if(address(this).balance>=CurrentPackFee){
feeTransfered=true;
creatorOwner.transfer(CurrentPackFee);
}
}
}
function deposit()public payable{
DepositTemp memory d;
d.userAmt=msg.value;
d.useraddress=msg.sender;
require(d.userAmt<250 * 1 ether);
d.availableTokens=balances[address(this)];
d.currentPackTokenPriceSellout=CurrentPackTokenPriceSellout;
require(d.userAmt<=d.availableTokens.mul(d.currentPackTokenPriceSellout).add(10*1 ether));
require(d.userAmt.div(d.currentPackTokenPriceSellout)>0);
d.currentPackNumber=CurrentPackNumber;
d.currentPackStartDate=CurrentPackStartDate;
d.userBuyTokenPackNum=users[d.useraddress].UserBuyTokenPackNum;
d.userBuyTokenPrevPack=users[d.useraddress].UserBuyTokenPrevPack;
if(d.userBuyTokenPackNum==d.currentPackNumber-1){
d.userBuyTokenPrevPack=true;
}else{
if(d.userBuyTokenPackNum==d.currentPackNumber&&d.userBuyTokenPrevPack==true){
d.userBuyTokenPrevPack=true;
}else{
d.userBuyTokenPrevPack=false;
}
}
d.userBuyFirstDate=users[d.useraddress].UserBuyFirstDate;
d.userBuyDate=users[d.useraddress].UserBuyDate;
d.userContinued=users[d.useraddress].UserContinued;
d.userTotalAmtDepositCurrentPack=users[d.useraddress].UserTotalAmtDepositCurrentPack;
d.userTotalAmtDeposit=users[d.useraddress].UserTotalAmtDeposit;
if(d.userBuyTokenPackNum==d.currentPackNumber&&d.userBuyDate>=d.currentPackStartDate){
require(d.userTotalAmtDepositCurrentPack.add(d.userAmt)<250*1 ether);
d.userAmtDepositCurrentPackTRUE=users[d.useraddress].UserAmtDepositCurrentPackTRUE;
}else{
d.userTotalAmtDepositCurrentPack=0;
d.userAmtDepositCurrentPackTRUE=0;
}
if(users[d.useraddress].UserSellTokenPackNum==d.currentPackNumber&&users[d.useraddress].UserSellDate>=d.currentPackStartDate){
d.p=users[d.useraddress].UserTotalAmtWithdrawalCurrentPack/20;
require(d.userAmt>d.p);
d.userAmt=d.userAmt.sub(d.p);
}
d.userTokenObtain=d.userAmt/d.currentPackTokenPriceSellout;
if(d.userTokenObtain*d.currentPackTokenPriceSellout<d.userAmt){
d.userTokenObtain=d.userTokenObtain+1;
}
if(d.userTokenObtain>d.availableTokens){
d.amtToSend=d.currentPackTokenPriceSellout*(d.userTokenObtain-d.availableTokens);
d.userAmt=d.userAmt.sub(d.amtToSend);
d.userTokenObtain=d.availableTokens;
}
if(d.userAmt>=100*1 finney){
if(now<=(d.currentPackStartDate+1*1 days)){
d.bonus=d.userTokenObtain*75/10000+1;
}else{
if(now<=(d.currentPackStartDate+2*1 days)){
d.bonus=d.userTokenObtain*50/10000+1;
}else{
if(now<=(d.currentPackStartDate+3*1 days)){
d.bonus=d.userTokenObtain*25/10000+1;
}
}
}
}
if(d.userContinued>=4&&now>=(d.userBuyFirstDate+1*1 weeks)){
d.bonus=d.bonus+d.userTokenObtain/100+1;
}
if(d.bonus>0){
d.userTokenObtain=d.userTokenObtain.add(d.bonus);
if(d.userTokenObtain>d.availableTokens){
d.userAmtOverloadToSend=d.currentPackTokenPriceSellout*(d.userTokenObtain-d.availableTokens);
d.bonusAmountRefunded=d.userAmtOverloadToSend;
d.userTokenObtain=d.availableTokens;
d.amtToSend=d.amtToSend.add(d.userAmtOverloadToSend);
d.bonus=0;
}else{
d.bonusAmount=d.bonus*d.currentPackTokenPriceSellout;
}
}
if(d.userBuyTokenPackNum==0){
d.userContinued=1;
d.userBuyFirstDate=now;
d.userFirstAmt=d.userAmt.add(d.bonusAmount);
d.userBuyFirstPack=d.currentPackNumber;
d.amtForfirstRefund=d.userFirstAmt*6/10;
OverallDisparityAmounts=OverallDisparityAmounts+d.userFirstAmt*7/10;
CurrentPackDisparityAmounts=CurrentPackDisparityAmounts+d.userFirstAmt*7/10;
d.amtToSend=d.amtToSend.add(d.amtForfirstRefund);
OverallRefunded=OverallRefunded+d.amtForfirstRefund;
}else{
d.userFirstAmt=users[d.useraddress].UserFirstAmt;
d.userBuyFirstPack=users[d.useraddress].UserBuyFirstPack;
if(d.userBuyTokenPrevPack==true){
if(d.userBuyTokenPackNum==d.currentPackNumber-1){
d.userContinued=d.userContinued+1;
}
}else{
d.userContinued=1;
}
}
d.userAmtToStore=d.userAmt.add(d.bonusAmount);
d.userTotalAmtDepositCurrentPack=d.userTotalAmtDepositCurrentPack.add(d.userAmtToStore);
d.userTotalAmtDeposit=d.userTotalAmtDeposit.add(d.userAmtToStore);
d.userAmtDepositCurrentPackTRUE=d.userAmtDepositCurrentPackTRUE.add(d.userAmtToStore);
CurrentPackDeposits=CurrentPackDeposits.add(d.userAmtToStore);
OverallDeposits=OverallDeposits.add(d.userAmtToStore);
transfer(address(this),d.useraddress,d.userTokenObtain,false,0,0);
User storage user=users[d.useraddress];
user.UserBuyFirstDate=d.userBuyFirstDate;
user.UserBuyFirstPack=d.userBuyFirstPack;
user.UserBuyTokenPackNum=d.currentPackNumber;
user.UserBuyDate=now;
user.UserFirstAmt=d.userFirstAmt;
user.UserBuyTokenPrevPack=d.userBuyTokenPrevPack;
user.UserContinued=d.userContinued;
user.UserTotalAmtDepositCurrentPack=d.userTotalAmtDepositCurrentPack;
user.UserTotalAmtDeposit=d.userTotalAmtDeposit;
user.UserAmtDepositCurrentPackTRUE=d.userAmtDepositCurrentPackTRUE;
restart(false);
if(balances[address(this)]==0){
nextPack(d.currentPackNumber);
}
emit Deposit(d.useraddress,d.userAmtToStore,d.amtForfirstRefund,d.bonusAmount,d.bonusAmountRefunded,0,d.userTokenObtain,d.bonus,d.currentPackNumber,d.amtToSend);
if(d.amtToSend>0){
d.useraddress.transfer(d.amtToSend);
}
}
function withdraw(uint WithdrawAmount,uint WithdrawTokens,bool AllowToUseDisparity)public{
require(WithdrawTokens>0||WithdrawAmount>0);
require(WithdrawTokens<=balances[msg.sender]);
WithdrawTemp memory w;
w.useraddress=msg.sender;
w.userFirstAmt=users[w.useraddress].UserFirstAmt;
w.userBuyFirstPack=users[w.useraddress].UserBuyFirstPack;
w.currentPackNumber=CurrentPackNumber;
w.currentPackStartDate=CurrentPackStartDate;
w.currentPackTokenPriceSellout=CurrentPackTokenPriceSellout;
w.currentPackTokenPriceBuyout=CurrentPackTokenPriceBuyout;
w.overallRefunded=OverallRefunded;
w.overallDisparityAmounts=OverallDisparityAmounts;
w.userTotalAmtWithdrawal=users[w.useraddress].UserTotalAmtWithdrawal;
w.userWithdrawalFromFirstRefunded=users[w.useraddress].UserWithdrawalFromFirstRefunded;
w.remainsFromFirstRefunded=(w.userFirstAmt*6/10).sub(w.userWithdrawalFromFirstRefunded);
w.userWithdrawalFromDisparity=users[w.useraddress].UserWithdrawalFromDisparity;
w.remainsFromDisparity=(w.userFirstAmt*7/10).sub(w.userWithdrawalFromDisparity);
w.thisBal=address(this).balance;
w.currentPackDeposits=CurrentPackDeposits;
if(users[w.useraddress].UserBuyTokenPackNum==w.currentPackNumber&&users[w.useraddress].UserBuyDate>=w.currentPackStartDate){
w.userTotalAmtDepositCurrentPack=users[w.useraddress].UserTotalAmtDepositCurrentPack;
w.userAmtDepositCurrentPackTRUE=users[w.useraddress].UserAmtDepositCurrentPackTRUE;
w.withdrawAmtToCurrentPack=users[w.useraddress].UserAmtDepositCurrentPackTRUE;
w.returnTokenInCurrentPack=true;
}else{
w.returnTokenInCurrentPack=false;
}
if(users[w.useraddress].UserSellTokenPackNum==w.currentPackNumber&&users[w.useraddress].UserSellDate>=w.currentPackStartDate){
w.userTotalAmtWithdrawalCurrentPack=users[w.useraddress].UserTotalAmtWithdrawalCurrentPack;
}
if(CurrentPackDeposits+OverallDisparityAmounts>CurrentPackDisparityAmounts+OverallRefunded){
w.dsp=CurrentPackDeposits+OverallDisparityAmounts-CurrentPackDisparityAmounts-OverallRefunded;
}else{
w.dsp=0;
}
w.userAvailableAmount=(balances[w.useraddress]-(w.withdrawAmtToCurrentPack/w.currentPackTokenPriceSellout))*w.currentPackTokenPriceBuyout+w.withdrawAmtToCurrentPack;
if(w.thisBal>=w.dsp){
if(w.userAvailableAmount>w.thisBal-w.dsp){
if(w.currentPackNumber==w.userBuyFirstPack){
if(w.userAvailableAmount>w.thisBal-w.dsp+w.userAmtDepositCurrentPackTRUE){
w.userAvailableAmount=w.thisBal-w.dsp+w.userAmtDepositCurrentPackTRUE;
}
}else{
if(w.userAvailableAmount>w.thisBal-w.dsp+w.remainsFromDisparity+w.userAmtDepositCurrentPackTRUE){
w.userAvailableAmount=w.thisBal-w.dsp+w.remainsFromDisparity+w.userAmtDepositCurrentPackTRUE;
}
}
}
}else{
if(w.userAmtDepositCurrentPackTRUE>w.remainsFromDisparity){
if(w.userAvailableAmount>w.userAmtDepositCurrentPackTRUE){
w.userAvailableAmount=w.userAmtDepositCurrentPackTRUE;
}
}else{
if(w.userAvailableAmount>w.remainsFromDisparity){
w.userAvailableAmount=w.remainsFromDisparity;
}
}
if(w.userAvailableAmount>w.thisBal+w.remainsFromFirstRefunded){
w.userAvailableAmount=w.thisBal+w.remainsFromFirstRefunded;
}
if(w.currentPackNumber>2){
w.ra=true;
}
}
if(WithdrawTokens>0&&WithdrawAmount==0){
w.userTokensReturn=WithdrawTokens;
if(w.returnTokenInCurrentPack==true){
w.userTokensReturnToCurrentPack=w.withdrawAmtToCurrentPack.div(w.currentPackTokenPriceSellout);
if(w.userTokensReturn>w.userTokensReturnToCurrentPack){
w.userTokensReturnAboveCurrentPack=w.userTokensReturn.sub(w.userTokensReturnToCurrentPack);
w.withdrawAmtAboveCurrentPack=w.userTokensReturnAboveCurrentPack.mul(w.currentPackTokenPriceBuyout);
}else{
w.withdrawAmtToCurrentPack=w.userTokensReturn.mul(w.currentPackTokenPriceSellout);
w.userTokensReturnToCurrentPack=w.userTokensReturn;
w.withdrawAmtAboveCurrentPack=0;
w.userTokensReturnAboveCurrentPack=0;
}
}else{
w.withdrawAmtToCurrentPack=0;
w.userTokensReturnToCurrentPack=0;
w.userTokensReturnAboveCurrentPack=w.userTokensReturn;
w.withdrawAmtAboveCurrentPack=w.userTokensReturnAboveCurrentPack.mul(w.currentPackTokenPriceBuyout);
}
w.withdrawAmt=w.withdrawAmtToCurrentPack.add(w.withdrawAmtAboveCurrentPack);
}else{
w.withdrawAmt=WithdrawAmount;
}
if(w.withdrawAmt>w.userAvailableAmount){
w.withdrawAmt=w.userAvailableAmount;
}
if(w.remainsFromDisparity>0){
if(w.userAvailableAmount>=w.remainsFromDisparity){
w.userAvailableAmount=w.userAvailableAmount-w.remainsFromDisparity;
}else{
w.userAvailableAmount=0;
}
}
if(w.userAvailableAmount<100){
w.userAvailableAmount=0;
}
if(AllowToUseDisparity==false&&w.remainsFromDisparity>0){
if(w.withdrawAmt>w.userAvailableAmount){
w.withdrawAmt=w.userAvailableAmount;
}
}
if(w.returnTokenInCurrentPack==true){
w.userTokensReturnToCurrentPack=w.withdrawAmtToCurrentPack.div(w.currentPackTokenPriceSellout);
if(w.withdrawAmt>w.withdrawAmtToCurrentPack){
w.withdrawAmtAboveCurrentPack=w.withdrawAmt.sub(w.withdrawAmtToCurrentPack);
w.userTokensReturnAboveCurrentPack=w.withdrawAmtAboveCurrentPack.div(w.currentPackTokenPriceBuyout);
}else{
w.withdrawAmtToCurrentPack=w.withdrawAmt;
w.userTokensReturnToCurrentPack=w.withdrawAmtToCurrentPack.div(w.currentPackTokenPriceSellout);
w.withdrawAmtAboveCurrentPack=0;
w.userTokensReturnAboveCurrentPack=0;
}
}else{
w.withdrawAmtToCurrentPack=0;
w.userTokensReturnToCurrentPack=0;
w.withdrawAmtAboveCurrentPack=w.withdrawAmt;
w.userTokensReturnAboveCurrentPack=w.withdrawAmtAboveCurrentPack.div(w.currentPackTokenPriceBuyout);
}
if(AllowToUseDisparity==true&&w.remainsFromDisparity>0){
if(w.withdrawAmt>w.userAvailableAmount){
w.useFromDisparity=w.withdrawAmt-w.userAvailableAmount;
if(w.remainsFromDisparity<w.useFromDisparity){
w.useFromDisparity=w.remainsFromDisparity;
}
w.userWithdrawalFromDisparity=w.userWithdrawalFromDisparity.add(w.useFromDisparity);
if(w.remainsFromFirstRefunded>0){
if(w.useFromDisparity>w.remainsFromDisparity-w.remainsFromFirstRefunded){
w.useFromFirstRefunded=w.useFromDisparity+w.remainsFromFirstRefunded-w.remainsFromDisparity;
if (w.remainsFromFirstRefunded<w.useFromFirstRefunded){
w.useFromFirstRefunded=w.remainsFromFirstRefunded;
}
w.userWithdrawalFromFirstRefunded=w.userWithdrawalFromFirstRefunded+w.useFromFirstRefunded;
w.withdrawAmt=w.withdrawAmt.sub(w.useFromFirstRefunded);
}
}
}
}
if(balances[address(this)]/50000000000000<10){
w.bonus=(w.withdrawAmt+w.useFromFirstRefunded)/100;
w.bonusToSend=w.bonus;
}
if(w.thisBal>w.dsp&&w.bonus>0){
if(w.withdrawAmt+w.bonus>w.thisBal-w.dsp){
w.bonusToSend=0;
w.diff=w.bonus;
if(w.userTokensReturnAboveCurrentPack>0){
w.bonusTokensReturnDecrease=w.diff/w.currentPackTokenPriceBuyout;
if(w.userTokensReturnAboveCurrentPack>=w.bonusTokensReturnDecrease){
w.userTokensReturnAboveCurrentPack=w.userTokensReturnAboveCurrentPack-w.bonusTokensReturnDecrease;
}else{
w.diff=w.bonusTokensReturnDecrease-w.userTokensReturnAboveCurrentPack;
w.userTokensReturnAboveCurrentPack=0;
w.bonusTokensReturnDecrease=w.diff*w.currentPackTokenPriceBuyout/w.currentPackTokenPriceSellout;
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.bonusTokensReturnDecrease;
}
}else{
w.bonusTokensReturnDecrease=w.diff/w.currentPackTokenPriceSellout;
if(w.userTokensReturnToCurrentPack>=w.bonusTokensReturnDecrease){
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.bonusTokensReturnDecrease;
}
}
}
}
if(w.thisBal<=w.dsp){
if(w.bonus>0){
w.bonusToSend=0;
w.diff=w.bonus;
if(w.userTokensReturnAboveCurrentPack>0){
w.bonusTokensReturnDecrease=w.diff/w.currentPackTokenPriceBuyout;
if(w.userTokensReturnAboveCurrentPack>=w.bonusTokensReturnDecrease){
w.userTokensReturnAboveCurrentPack=w.userTokensReturnAboveCurrentPack-w.bonusTokensReturnDecrease;
}else{
w.diff=w.bonusTokensReturnDecrease-w.userTokensReturnAboveCurrentPack;
w.userTokensReturnAboveCurrentPack=0;
w.bonusTokensReturnDecrease=w.diff*w.currentPackTokenPriceBuyout/w.currentPackTokenPriceSellout;
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.bonusTokensReturnDecrease;
}
}else{
w.bonusTokensReturnDecrease=w.diff/w.currentPackTokenPriceSellout;
if(w.userTokensReturnToCurrentPack>=w.bonusTokensReturnDecrease){
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.bonusTokensReturnDecrease;
}
}
}
if(w.withdrawAmt>w.thisBal){
w.diff=w.withdrawAmt+100-w.thisBal;
if(w.userTokensReturnAboveCurrentPack>0){
w.TokensReturnDecrease=w.diff/w.currentPackTokenPriceBuyout;
if(w.userTokensReturnAboveCurrentPack>=w.TokensReturnDecrease){
w.userTokensReturnAboveCurrentPack=w.userTokensReturnAboveCurrentPack-w.TokensReturnDecrease;
w.withdrawAmtAboveCurrentPack=w.userTokensReturnAboveCurrentPack*w.currentPackTokenPriceBuyout;
}else{
w.diff=w.TokensReturnDecrease-w.userTokensReturnAboveCurrentPack;
w.userTokensReturnAboveCurrentPack=0;
w.TokensReturnDecrease=w.diff*w.currentPackTokenPriceBuyout/w.currentPackTokenPriceSellout;
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.TokensReturnDecrease;
}
}else{
w.TokensReturnDecrease=w.diff/w.currentPackTokenPriceSellout;
if(w.userTokensReturnToCurrentPack>=w.TokensReturnDecrease){
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.TokensReturnDecrease;
w.withdrawAmtToCurrentPack=w.userTokensReturnToCurrentPack*w.currentPackTokenPriceSellout;
}
}
w.withdrawAmt=w.withdrawAmtToCurrentPack+w.withdrawAmtAboveCurrentPack;
if(w.withdrawAmt>=w.useFromFirstRefunded){
w.withdrawAmt=w.withdrawAmt-w.useFromFirstRefunded;
}else{
w.diff=w.useFromFirstRefunded-w.withdrawAmt;
w.withdrawAmt=0;
w.useFromFirstRefunded=w.useFromFirstRefunded-w.diff;
}
if(w.withdrawAmt>w.thisBal){
w.withdrawAmt=w.thisBal;
}
}
}
User storage user=users[w.useraddress];
if(w.userAmtDepositCurrentPackTRUE>w.withdrawAmtToCurrentPack){
user.UserAmtDepositCurrentPackTRUE=w.userAmtDepositCurrentPackTRUE-w.withdrawAmtToCurrentPack;
}else{
user.UserAmtDepositCurrentPackTRUE=0;
}
if(w.overallDisparityAmounts>w.useFromDisparity){
OverallDisparityAmounts=w.overallDisparityAmounts-w.useFromDisparity;
}else{
OverallDisparityAmounts=0;
}
if(w.userBuyFirstPack==w.currentPackNumber&&users[w.useraddress].UserBuyFirstDate>=w.currentPackStartDate){
if(CurrentPackDisparityAmounts>w.useFromDisparity){
CurrentPackDisparityAmounts=CurrentPackDisparityAmounts-w.useFromDisparity;
}else{
CurrentPackDisparityAmounts=0;
}
}
if(w.overallRefunded>w.useFromFirstRefunded){
OverallRefunded=w.overallRefunded-w.useFromFirstRefunded;
}else{
OverallRefunded=0;
}
if(w.currentPackDeposits>w.withdrawAmtToCurrentPack){
CurrentPackDeposits=w.currentPackDeposits-w.withdrawAmtToCurrentPack;
}else{
CurrentPackDeposits=0;
}
w.userTokensReturn=w.userTokensReturnToCurrentPack+w.userTokensReturnAboveCurrentPack;
w.wAtoStore=w.withdrawAmt+w.useFromFirstRefunded+w.bonusToSend;
w.userTotalAmtWithdrawal=w.userTotalAmtWithdrawal+w.wAtoStore;
w.userTotalAmtWithdrawalCurrentPack=w.userTotalAmtWithdrawalCurrentPack+w.wAtoStore;
OverallWithdrawals=OverallWithdrawals+w.wAtoStore;
user.UserSellTokenPackNum=w.currentPackNumber;
user.UserSellDate=now;
user.UserTotalAmtWithdrawal=w.userTotalAmtWithdrawal;
user.UserTotalAmtWithdrawalCurrentPack=w.userTotalAmtWithdrawalCurrentPack;
user.UserWithdrawalFromFirstRefunded=w.userWithdrawalFromFirstRefunded;
user.UserWithdrawalFromDisparity=w.userWithdrawalFromDisparity;
emit Withdraw(w.useraddress,w.wAtoStore,w.useFromFirstRefunded,w.bonus,w.bonusToSend,w.currentPackNumber,w.userTokensReturn,w.userTokensReturnToCurrentPack,w.bonusTokensReturnDecrease,w.TokensReturnDecrease);
if (w.userTokensReturn==balances[w.useraddress]+1){
w.userTokensReturn=balances[w.useraddress];
if (w.userTokensReturnToCurrentPack==balances[w.useraddress]+1){
w.userTokensReturnToCurrentPack=balances[w.useraddress];
}
if (w.userTokensReturnAboveCurrentPack==balances[w.useraddress]+1){
w.userTokensReturnAboveCurrentPack=balances[w.useraddress];
}
}
transfer(w.useraddress,address(this),w.userTokensReturn,w.returnTokenInCurrentPack,w.userTokensReturnToCurrentPack,w.userTokensReturnAboveCurrentPack);
if(w.ra==true){
restart(true);
}
if(w.withdrawAmt+w.bonus>0){
w.useraddress.transfer(w.withdrawAmt+w.bonusToSend);
}
}
function transfer(address _from,address _to,uint _value,bool _rttcp,uint _rtcp,uint _racp)internal returns(bool success){
balances[_from]=balances[_from].sub(_value);
if(_to==address(this)){
if(_rttcp==true){
balances[_to]=balances[_to].add(_rtcp);
}else{
balances[_to]=balances[_to];
}
totalSupply=totalSupply.sub(_racp);
}else{
balances[_to]=balances[_to].add(_value);
}
emit Transfer(_from,_to,_value);
return true;
}
function balanceOf(address tokenOwner)public view returns(uint balance){
return balances[tokenOwner];
}
function mint(uint _value)internal returns(bool){
balances[address(this)]=balances[address(this)].add(_value);
totalSupply=totalSupply.add(_value);
return true;
}
event Deposit(address indexed addr,uint,uint,uint,uint,uint,uint,uint,uint,uint);
event Withdraw(address indexed addr,uint,uint,uint,uint,uint,uint,uint,uint,uint);
event Transfer(address indexed _from,address indexed _to,uint _value);
event NextPack(uint indexed CurrentPackTokenPriceSellout,uint indexed CurrentPackTokenPriceBuyout);
}
| 339,537 | 12,800 |
f6a9ef12aa91c03695be303a6c93c2883e8e635e0d5918e824d15f4f51f4fedb
| 8,245 |
.sol
|
Solidity
| false |
594891767
|
otter-sec/battle-of-titans
|
c5f7890ea2bf9ffe6bc3286528e6300f09761f47
|
src/utils/SignedWadMath.sol
| 3,768 | 8,185 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
/// @title Signed Wad Math
/// @author transmissions11 <t11s@paradigm.xyz>
/// @author FrankieIsLost <frankie@paradigm.xyz>
/// @notice Efficient signed wad arithmetic.
/// @dev Will not revert on overflow, only use where overflow is not possible.
function toWadUnsafe(uint256 x) pure returns (int256 r) {
assembly {
// Multiply x by 1e18.
r := mul(x, 1000000000000000000)
}
}
/// @dev Will not revert on overflow, only use where overflow is not possible.
function unsafeWadMul(int256 x, int256 y) pure returns (int256 r) {
assembly {
// Multiply x by y and divide by 1e18.
r := sdiv(mul(x, y), 1000000000000000000)
}
}
/// @dev Will return 0 instead of reverting if y is zero and will
/// not revert on overflow, only use where overflow is not possible.
function unsafeWadDiv(int256 x, int256 y) pure returns (int256 r) {
assembly {
// Multiply x by 1e18 and divide it by y.
r := sdiv(mul(x, 1000000000000000000), y)
}
}
function wadMul(int256 x, int256 y) pure returns (int256 r) {
assembly {
// Store x * y in r for now.
r := mul(x, y)
// Equivalent to require(x == 0 || (x * y) / x == y)
if iszero(or(iszero(x), eq(sdiv(r, x), y))) {
revert(0, 0)
}
// Scale the result down by 1e18.
r := sdiv(r, 1000000000000000000)
}
}
function wadDiv(int256 x, int256 y) pure returns (int256 r) {
assembly {
// Store x * 1e18 in r for now.
r := mul(x, 1000000000000000000)
// Equivalent to require(y != 0 && ((x * 1e18) / 1e18 == x))
if iszero(and(iszero(iszero(y)), eq(sdiv(r, 1000000000000000000), x))) {
revert(0, 0)
}
// Divide r by y.
r := sdiv(r, y)
}
}
function wadExp(int256 x) pure returns (int256 r) {
unchecked {
// When the result is < 0.5 we return zero. This happens when
// x <= floor(log(0.5e18) * 1e18) ~ -42e18
if (x <= -42139678854452767551) {
return 0;
}
// When the result is > (2**255 - 1) / 1e18 we can not represent it as an
// int. This happens when x >= floor(log((2**255 - 1) / 1e18) * 1e18) ~ 135.
if (x >= 135305999368893231589) {
revert("EXP_OVERFLOW");
}
// x is now in the range (-42, 136) * 1e18. Convert to (-42, 136) * 2**96
// for more intermediate precision and a binary basis. This base conversion
// is a multiplication by 1e18 / 2**96 = 5**18 / 2**78.
x = (x << 78) / 5 ** 18;
// Reduce range of x to (- ln 2, ln 2) * 2**96 by factoring out powers
// of two such that exp(x) = exp(x') * 2**k, where k is an integer.
// Solving this gives k = round(x / log(2)) and x' = x - k * log(2).
int256 k = ((x << 96) / 54916777467707473351141471128 + 2 ** 95) >> 96;
x = x - k * 54916777467707473351141471128;
// k is in the range [-61, 195].
// Evaluate using a (6, 7)-term rational approximation.
// p is made monic, we'll multiply by a scale factor later.
int256 y = x + 1346386616545796478920950773328;
y = ((y * x) >> 96) + 57155421227552351082224309758442;
int256 p = y + x - 94201549194550492254356042504812;
p = ((p * y) >> 96) + 28719021644029726153956944680412240;
p = p * x + (4385272521454847904659076985693276 << 96);
// We leave p in 2**192 basis so we don't need to scale it back up for the division.
int256 q = x - 2855989394907223263936484059900;
q = ((q * x) >> 96) + 50020603652535783019961831881945;
q = ((q * x) >> 96) - 533845033583426703283633433725380;
q = ((q * x) >> 96) + 3604857256930695427073651918091429;
q = ((q * x) >> 96) - 14423608567350463180887372962807573;
q = ((q * x) >> 96) + 26449188498355588339934803723976023;
assembly {
// Div in assembly because solidity adds a zero check despite the unchecked.
// The q polynomial won't have zeros in the domain as all its roots are complex.
// No scaling is necessary because p is already 2**96 too large.
r := sdiv(p, q)
}
// r should be in the range (0.09, 0.25) * 2**96.
// We now need to multiply r by:
// * the scale factor s = ~6.031367120.
// * the 2**k factor from the range reduction.
// * the 1e18 / 2**96 factor for base conversion.
// We do this all at once, with an intermediate result in 2**213
// basis, so the final right shift is always by a positive amount.
r = int256((uint256(r) * 3822833074963236453042738258902158003155416615667) >>
uint256(195 - k));
}
}
function wadLn(int256 x) pure returns (int256 r) {
unchecked {
require(x > 0, "UNDEFINED");
// We want to convert x from 10**18 fixed point to 2**96 fixed point.
// We do this by multiplying by 2**96 / 10**18. But since
// ln(x * C) = ln(x) + ln(C), we can simply do nothing here
// and add ln(2**96 / 10**18) at the end.
assembly {
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
r := or(r, shl(2, lt(0xf, shr(r, x))))
r := or(r, shl(1, lt(0x3, shr(r, x))))
r := or(r, lt(0x1, shr(r, x)))
}
// Reduce range of x to (1, 2) * 2**96
// ln(2^k * x) = k * ln(2) + ln(x)
int256 k = r - 96;
x <<= uint256(159 - k);
x = int256(uint256(x) >> 159);
// Evaluate using a (8, 8)-term rational approximation.
// p is made monic, we will multiply by a scale factor later.
int256 p = x + 3273285459638523848632254066296;
p = ((p * x) >> 96) + 24828157081833163892658089445524;
p = ((p * x) >> 96) + 43456485725739037958740375743393;
p = ((p * x) >> 96) - 11111509109440967052023855526967;
p = ((p * x) >> 96) - 45023709667254063763336534515857;
p = ((p * x) >> 96) - 14706773417378608786704636184526;
p = p * x - (795164235651350426258249787498 << 96);
// We leave p in 2**192 basis so we don't need to scale it back up for the division.
// q is monic by convention.
int256 q = x + 5573035233440673466300451813936;
q = ((q * x) >> 96) + 71694874799317883764090561454958;
q = ((q * x) >> 96) + 283447036172924575727196451306956;
q = ((q * x) >> 96) + 401686690394027663651624208769553;
q = ((q * x) >> 96) + 204048457590392012362485061816622;
q = ((q * x) >> 96) + 31853899698501571402653359427138;
q = ((q * x) >> 96) + 909429971244387300277376558375;
assembly {
// Div in assembly because solidity adds a zero check despite the unchecked.
// The q polynomial is known not to have zeros in the domain.
// No scaling required because p is already 2**96 too large.
r := sdiv(p, q)
}
// r is in the range (0, 0.125) * 2**96
// Finalization, we need to:
// * multiply by the scale factor s = 5.549
// * add ln(2**96 / 10**18)
// * add k * ln(2)
// * multiply by 10**18 / 2**96 = 5**18 >> 78
// mul s * 5e18 * 2**96, base is now 5**18 * 2**192
r *= 1677202110996718588342820967067443963516166;
// add ln(2) * k * 5e18 * 2**192
r +=
16597577552685614221487285958193947469193820559219878177908093499208371 *
k;
// add ln(2**96 / 10**18) * 5e18 * 2**192
r += 600920179829731861736702779321621459595472258049074101567377883020018308;
// base conversion: mul 2**18 / 2**192
r >>= 174;
}
}
/// @dev Will return 0 instead of reverting if y is zero.
function unsafeDiv(int256 x, int256 y) pure returns (int256 r) {
assembly {
// Divide x by y.
r := sdiv(x, y)
}
}
| 283,410 | 12,801 |
266f475c844fc93a2286325fe6d2f7e322148a5793dc67b8dcd7c628822d946c
| 13,234 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/60/606fd8c1f84a06039fe7ab547b133cbfd25ae314_CreditERC20Token.sol
| 2,897 | 10,734 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library 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);
}
/// @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);
}
/// @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));
}
}
abstract contract ERC20 is IERC20 {
using LowGasSafeMath for uint256;
// Present in ERC777
mapping (address => uint256) internal _balances;
// Present in ERC777
mapping (address => mapping (address => uint256)) internal _allowances;
// Present in ERC777
uint256 internal _totalSupply;
// Present in ERC777
string internal _name;
// Present in ERC777
string internal _symbol;
// Present in ERC777
uint8 internal _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender]
.sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender]
.sub(subtractedValue));
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);
_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(this), 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);
_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 { }
}
library Counters {
using LowGasSafeMath for uint256;
struct Counter {
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);
}
}
interface IERC2612Permit {
function permit(address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
}
abstract contract ERC20Permit is ERC20, IERC2612Permit {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
bytes32 public DOMAIN_SEPARATOR;
constructor() {
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")), // Version
chainID,
address(this)));
}
function permit(address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "Permit: expired deadline");
bytes32 hashStruct =
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, amount, _nonces[owner].current(), deadline));
bytes32 _hash = keccak256(abi.encodePacked(uint16(0x1901), DOMAIN_SEPARATOR, hashStruct));
address signer = ecrecover(_hash, v, r, s);
require(signer != address(0) && signer == owner, "ERC20Permit: Invalid signature");
_nonces[owner].increment();
_approve(owner, spender, amount);
}
function nonces(address owner) public view override returns (uint256) {
return _nonces[owner].current();
}
}
interface IOwnable {
function owner() external view returns (address);
function renounceOwnership() external;
function transferOwnership(address newOwner_) external;
}
contract Ownable is IOwnable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view override returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual override onlyOwner() {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner_) public virtual override onlyOwner() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner_);
_owner = newOwner_;
}
}
contract VaultOwned is Ownable {
address internal _vault;
event VaultTransferred(address indexed newVault);
function setVault(address vault_) external onlyOwner() {
require(vault_ != address(0), "IA0");
_vault = vault_;
emit VaultTransferred(_vault);
}
function vault() public view returns (address) {
return _vault;
}
modifier onlyVault() {
require(_vault == msg.sender, "VaultOwned: caller is not the Vault");
_;
}
}
contract CreditERC20Token is ERC20Permit, VaultOwned {
using LowGasSafeMath for uint256;
constructor() ERC20("Credit", "CRDT", 9) {
}
function mint(address account_, uint256 amount_) external onlyVault() {
_mint(account_, amount_);
}
function burn(uint256 amount) external virtual {
_burn(msg.sender, amount);
}
function burnFrom(address account_, uint256 amount_) external virtual {
_burnFrom(account_, amount_);
}
function _burnFrom(address account_, uint256 amount_) internal virtual {
uint256 decreasedAllowance_ =
allowance(account_, msg.sender).sub(amount_);
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
}
| 125,302 | 12,802 |
0972e54c1c7bad32804417f0f3cee651cc0289f24de9e5b77a418c58edbfc4ad
| 15,499 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/94/94178bEe87193C6FeE39dA35EAdEC16bDB5283E7_Distributor.sol
| 3,387 | 13,842 |
// 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 BIG;
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 _big, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
require(_big != address(0));
treasury = ITreasury(_treasury);
BIG = IERC20(_big);
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 BIG.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
});
}
}
| 310,448 | 12,803 |
0d28b6519b0ec3fb299138c2a6648f72c0fec10b32c52f11f15d8ccd2cf86cb9
| 33,001 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/cb/cb15ca455a0450eacaec1d4e2830103ee8734760_ProxyAdmin.sol
| 3,531 | 14,771 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
// solhint-disable-next-line no-inline-assembly
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback () external payable virtual {
_fallback();
}
receive () external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {
}
}
interface IBeacon {
function implementation() external view returns (address);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallSecure(address newImplementation, bytes memory data, bool forceCall) internal {
address oldImplementation = _getImplementation();
// Initial upgrade and setup call
_setImplementation(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
// Perform rollback test if not already in progress
StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
if (!rollbackTesting.value) {
// Trigger rollback using upgradeTo from the new implementation
rollbackTesting.value = true;
Address.functionDelegateCall(newImplementation,
abi.encodeWithSignature("upgradeTo(address)",
oldImplementation));
rollbackTesting.value = false;
// Check rollback was effective
require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
// Finally reset to the new implementation and log the upgrade
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
}
function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon),
"ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
}
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) {
assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation() external ifAdmin returns (address implementation_) {
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "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 ProxyAdmin is Ownable {
function getProxyImplementation(TransparentUpgradeableProxy proxy) public view virtual returns (address) {
// We need to manually run the static call since the getter cannot be flagged as view
// bytes4(keccak256("implementation()")) == 0x5c60da1b
(bool success, bytes memory returndata) = address(proxy).staticcall(hex"5c60da1b");
require(success);
return abi.decode(returndata, (address));
}
function getProxyAdmin(TransparentUpgradeableProxy proxy) public view virtual returns (address) {
// We need to manually run the static call since the getter cannot be flagged as view
// bytes4(keccak256("admin()")) == 0xf851a440
(bool success, bytes memory returndata) = address(proxy).staticcall(hex"f851a440");
require(success);
return abi.decode(returndata, (address));
}
function changeProxyAdmin(TransparentUpgradeableProxy proxy, address newAdmin) public virtual onlyOwner {
proxy.changeAdmin(newAdmin);
}
function upgrade(TransparentUpgradeableProxy proxy, address implementation) public virtual onlyOwner {
proxy.upgradeTo(implementation);
}
function upgradeAndCall(TransparentUpgradeableProxy proxy, address implementation, bytes memory data) public payable virtual onlyOwner {
proxy.upgradeToAndCall{value: msg.value}(implementation, data);
}
}
| 100,997 | 12,804 |
8acb1fffcbea731502842a1e427badffbc65a9f2791a49df577af00f02132d21
| 23,741 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/d7/d7a0dB81e67e5819071AF78AbEdB61b823465609_AvaxApex.sol
| 4,964 | 17,619 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract Owner is Context {
address private _owner;
event DefinedOwner(address indexed previousOwner, address indexed newOwner);
constructor (address owner_) {
_owner = owner_;
emit DefinedOwner(address(0), owner_);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Only owner: caller is not the owner");
_;
}
}
contract Dev is Context, Owner{
address private _dev;
event DefinedDev(address indexed previousDev, address indexed newDev);
constructor (address payable owner) Owner(owner) {
address msgSender = _msgSender();
_dev = msgSender;
emit DefinedDev(address(0), msgSender);
}
function dev() public view returns (address) {
return _dev;
}
modifier onlyDev() {
require(_dev == _msgSender(), "Dev function: caller is not the dev");
_;
}
function renounceDev() public onlyDev {
emit DefinedDev(_dev, address(0));
_dev = address(0);
}
function transferDev(address newDev) public onlyOwner {
_transferDevFunction(newDev);
}
function _transferDevFunction(address newDev) internal {
require(newDev != address(0), "Dev function: new dev is the zero address");
emit DefinedDev(_dev, newDev);
_dev = newDev;
}
}
contract AvaxApex is Dev {
using SafeMath for uint256;
using SafeMath for uint8;
uint256[] public REFERRAL_PERCENTS = [70, 30];
uint256 constant public PROJECT_FEE = 100;
uint256 constant public CONTRACT_FEE = 30;
uint256 constant public AMOUNT_MIN_INVEST= 10000000000000000 wei;
uint256 constant public AMOUNT_MIN_WITHDRAWN = 15000000000000000 wei;
uint256 constant public AMOUNT_MAX_INVEST= 25 ether;
uint256 constant public AMOUNT_MAX_WITHDRAWN = 25 ether;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public PERCENTS_PENALTY = 100;
uint256 constant public PERCENTS_ALLOWED_BALANCE = 250;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public DAYS_NOT_WHALE = 2 days;
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
bool public started;
uint256 public totalInvested;
uint256 public totalFunded;
uint256 public totalCommisions;
uint256 public totalUsers;
uint256 public totalUserBlocked;
struct Plan {
uint256 time;
uint256 percent;
}
struct BlockedState{
uint256 date;
uint8 times;
bool state;
uint256 investPenalty;
}
struct Deposit {
uint8 plan;
uint256 amount;
uint256 start;
}
struct Referred {
uint8 level;
uint256 amountPaid;
}
struct User {
Deposit[] deposits;
uint256 referralsCount;
mapping(address => Referred) referrals;
uint256[2] percentReferral;
address[2] referral;
uint256 checkpoint;
uint256 bonus;
uint256 totalBonus;
uint256 totalReinvest;
uint256 withdrawn;
BlockedState blocked;
}
//Mappings
mapping (address => User) internal users;
Plan[] internal plans;
address payable public commissionWallet;
// Events for emit
event Invest(address indexed user, uint8 plan, uint256 amount);
event ReInvest(address indexed user, uint8 plan, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event Funded(address indexed user, uint256 amount);
event BlockedWhale(address indexed user);
constructor(address payable wallet) Dev(wallet){
commissionWallet = wallet;
plans.push(Plan(20, 100));
_status = _NOT_ENTERED;
}
function invest(address referrer, uint8 plan) public payable nonReentrant{
if (!started) {
if (_msgSender() == commissionWallet) {
started = true;
} else revert("Not started yet");
}
require(plan < 1, "Invalid plan");
require(msg.value >= AMOUNT_MIN_INVEST, "Amount less than authorized");
require(msg.value <= AMOUNT_MAX_INVEST, "Amount greater than authorized");
paidFee(msg.value);
User storage user = users[_msgSender()];
if (user.deposits.length == 0) {
definedNewUser(user, referrer);
}
if(msg.value > user.blocked.investPenalty){
resetBlocked();
}else{
user.blocked.investPenalty = user.blocked.investPenalty.sub(msg.value);
}
paidReferrers(msg.value);
user.deposits.push(Deposit(plan, msg.value, block.timestamp));
totalInvested = totalInvested.add(msg.value);
emit Invest(_msgSender(), plan, msg.value);
}
function reInvest() public nonReentrant {
User storage user = users[_msgSender()];
uint256 totalAmount = getUserAvailableWithdraw(_msgSender());
if(totalAmount > user.blocked.investPenalty){
resetBlocked();
}else{
user.blocked.investPenalty = user.blocked.investPenalty.sub(totalAmount);
}
paidReferrers(totalAmount);
user.deposits.push(Deposit(0, totalAmount, block.timestamp));
user.checkpoint = block.timestamp;
user.totalReinvest = user.totalReinvest.add(totalAmount);
user.bonus = 0;
emit ReInvest(_msgSender(), 0, totalAmount);
}
function withdraw() public nonReentrant{
User storage user = users[_msgSender()];
require(user.checkpoint.add(TIME_STEP) <= block.timestamp, "Can only withdraw every 24 hours");
uint256 totalAmount = getUserAvailableWithdraw(_msgSender());
uint256 balanceAllowed = address(this).balance.mul(PERCENTS_ALLOWED_BALANCE).div(PERCENTS_DIVIDER);
totalAmount = totalAmount.sub(totalAmount.mul(CONTRACT_FEE).div(PERCENTS_DIVIDER));
definedBLocked(user, totalAmount);
require(!user.blocked.state, "Address is blocked");
require(totalAmount > 0, "User has no dividends");
require(totalAmount > AMOUNT_MIN_WITHDRAWN, "Amount less than authorized");
require(balanceAllowed > totalAmount, "Dividends amount not allowed");
if(totalAmount > AMOUNT_MAX_WITHDRAWN){
user.bonus = totalAmount.sub(AMOUNT_MAX_WITHDRAWN);
user.totalBonus = totalAmount.sub(AMOUNT_MAX_WITHDRAWN);
totalAmount = AMOUNT_MAX_WITHDRAWN;
}else {
user.bonus = 0;
}
user.checkpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
payable(_msgSender()).transfer(totalAmount);
emit Withdrawn(_msgSender(), totalAmount);
}
function fundContract() public payable nonReentrant {
if (!started) {
if (msg.sender == commissionWallet) {
started = true;
} else revert("Not started yet");
}
totalFunded = totalFunded.add(msg.value);
emit Funded(msg.sender, msg.value);
}
function changePercentReferrer(address user, uint8 index, uint256 percent) public onlyDev onlyOwner{
require(user != address(0));
require(index < REFERRAL_PERCENTS.length, "I don't exist level");
require(percent >= REFERRAL_PERCENTS[index], "Percent not allowed");
require(percent <= REFERRAL_PERCENTS[index].add(3), "Percent not allowed");
definedPercentReferrer(user, index, percent);
}
function getUserDividends(address user_) public view returns (uint256) {
User storage user = users[user_];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
uint256 finish = user.deposits[i].start.add(plans[user.deposits[i].plan].time.mul(1 days));
if (user.checkpoint < finish) {
uint256 share = user.deposits[i].amount.mul(plans[user.deposits[i].plan].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = finish < block.timestamp ? finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
}
}
return totalAmount;
}
/// @dev Functions that help to show info
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getUserTotalWithdrawn(address user) public view returns (uint256) {
return users[user].withdrawn;
}
function getUserCheckpoint(address user) public view returns(uint256) {
return users[user].checkpoint;
}
function getUserTotalDeposits(address user) public view returns(uint256) {
uint256 total = 0;
for(uint256 index = 0; index < users[user].deposits.length; index++) {
total = total.add(users[user].deposits[index].amount);
}
return total;
}
function getUserReferrer(address user) public view returns(address) {
return users[user].referral[0];
}
function getUserReferralsCount(address user_) public view returns(uint256) {
return users[user_].referralsCount;
}
function getUserReferralBonus(address user) public view returns(uint256) {
return users[user].bonus;
}
function getUserReferralTotalBonus(address user) public view returns(uint256) {
return users[user].totalBonus;
}
function getUserReferralWithdrawn(address user) public view returns(uint256) {
return users[user].totalBonus.sub(users[user].bonus);
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getUserInfoBlocked(address user_) public view returns(bool state, uint8 times, uint256 investPenalty, uint256 date) {
BlockedState memory _blocked = users[user_].blocked;
state = _blocked.state;
times = _blocked.times;
investPenalty = _blocked.investPenalty;
date = _blocked.date;
}
function getUserDepositInfo(address user_, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 start, uint256 finish) {
User storage user = users[user_];
plan = user.deposits[index].plan;
percent = plans[plan].percent;
amount = user.deposits[index].amount;
start = user.deposits[index].start;
finish = user.deposits[index].start.add(plans[user.deposits[index].plan].time.mul(1 days));
}
function getUserPercentReferrerInfo(address user_, uint8 index) public view returns(uint256) {
return users[user_].percentReferral[index];
}
function getUserReferenceInfo(address user_, address referral_) public view returns(uint256 percent, uint256 amount) {
percent = users[user_].referrals[referral_].level;
amount = users[user_].referrals[referral_].amountPaid;
}
function getUserAvailableWithdraw(address user_) public view returns(uint256) {
return getUserDividends(user_).add(getUserReferralBonus(user_));
}
function getUsertotalReinvestInfo(address user_) public view returns(uint256) {
return users[user_].totalReinvest;
}
function getUserInfo(address user_) public view
returns(uint256 checkpoint, bool blocked, uint256 numberReferral, uint256 totalBonus,uint256 totalDeposits, uint256 withdrawn, uint256 totalReinvest, uint256 available) {
checkpoint = getUserCheckpoint(user_);
blocked = users[user_].blocked.state;
numberReferral = getUserReferralsCount(user_);
totalBonus = getUserReferralTotalBonus(user_);
withdrawn = getUserTotalWithdrawn(user_);
totalReinvest = getUsertotalReinvestInfo(user_);
totalDeposits = getUserTotalDeposits(user_);
available = getUserAvailableWithdraw(user_);
}
/// @dev Utils and functions internal
function definedBLocked(User storage user, uint256 amount) internal {
if(user.blocked.times > 1){
user.blocked.state = true;
user.blocked.investPenalty = amount.mul(PERCENTS_PENALTY).div(PERCENTS_DIVIDER);
totalUserBlocked++;
if(user.blocked.date == 0){
user.blocked.date = block.timestamp.add(DAYS_NOT_WHALE);
}else if(user.blocked.date <= block.timestamp) {
user.blocked.state = false;
totalUserBlocked--;
}
}
}
function resetBlocked() internal {
users[_msgSender()].blocked.state = false;
users[_msgSender()].blocked.investPenalty = 0;
users[_msgSender()].blocked.date = 0;
users[_msgSender()].blocked.times = 0;
}
function definedReferrers(address referrer_) internal {
for(uint8 index = 0; index < REFERRAL_PERCENTS.length; index++) {
address referrer = index > 0 ? users[referrer_].referral[index.sub(1)] : referrer_;
if(referrer != address(0)){
users[_msgSender()].referral[index] = referrer;
users[referrer].referrals[_msgSender()] = Referred(0,index.add(1));
users[referrer].referralsCount = users[referrer].referralsCount.add(1);
}else break;
}
}
function paidReferrers(uint256 _amount) internal {
for(uint8 index = 0; index < REFERRAL_PERCENTS.length; index++) {
address referrer = users[_msgSender()].referral[index];
if(referrer != address(0)){
uint256 amount = _amount.mul(users[referrer].percentReferral[index]).div(PERCENTS_DIVIDER);
User storage user = users[referrer];
user.bonus = user.bonus.add(amount);
user.totalBonus = user.totalBonus.add(amount);
user.referrals[_msgSender()].amountPaid = user.referrals[_msgSender()].amountPaid.add(amount);
}else break;
}
}
function definedPercentReferrer(address user_, uint8 index, uint256 percent) internal{
users[user_].percentReferral[index] = percent;
}
function paidFee(uint256 amount) internal {
uint256 fee = amount.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
totalCommisions = totalCommisions.add(fee);
}
function definedNewUser(User storage user, address referrer) internal{
if(users[referrer].deposits.length > 0){
definedReferrers(referrer);
}
user.checkpoint = block.timestamp;
for(uint8 index = 0; index < REFERRAL_PERCENTS.length; index++){
definedPercentReferrer(_msgSender(), index, REFERRAL_PERCENTS[index]);
}
totalUsers++;
}
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;
}
}
| 118,054 | 12,805 |
d7cf58f208d1b4bf6a829b241d74ced5924f85ebd7262be565f4b544e9d5726c
| 15,064 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xEdF6a21f440f688329Ff86B00A5140975D05e715/contract.sol
| 4,539 | 14,199 |
// SPDX-License-Identifier: MIT
// Website : www.bnbjungle.com
pragma solidity ^0.5.10;
contract BNBJungle{
using SafeMath for uint256;
uint256 public BANNA_TO_HARVEST=2592000;
uint256 PSN=10000;
uint256 PSNH=5000;
bool public initialized=false;
address payable public ceoAddress;
address payable public ceoAddress2;
address public owner;
mapping (address => uint256) public bananaMonkeys;
mapping (address => uint256) public claimedBananas;
mapping (address => uint256) public lastReinvest;
mapping (address => address) public referrals;
uint256 public marketBananas;
uint256 constant public INVEST_MIN_AMOUNT = 5e16; // 0.05 bnb
uint256[] public REFERRAL_PERCENTS = [70, 30, 15, 10, 5];
uint256 constant public PROJECT_FEE = 100;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
bool public paused = true;
uint256 public totalInvested;
uint256 public totalRefBonus;
Plan[] internal plans;
struct Plan {
uint256 time;
uint256 percent;
}
struct Deposit {
uint8 plan;
uint256 amount;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256[5] levels;
uint256 bonus;
uint256 totalBonus;
uint256 withdrawn;
}
address payable public commissionWallet;
mapping (address => User) internal users;
bool public started;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable wallet) public{
ceoAddress=msg.sender;
ceoAddress2=address(wallet);
require(!isContract(wallet));
commissionWallet = wallet;
plans.push(Plan(10000, 20));
plans.push(Plan(40, 40));
plans.push(Plan(60, 35));
plans.push(Plan(90, 30));
owner = msg.sender;
}
function planInvest(address referrer, uint8 plan) public payable {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
if (!started) {
if (msg.sender == commissionWallet) {
started = true;
} else revert("Not started yet");
}
require(msg.value >= INVEST_MIN_AMOUNT);
require(plan < 4, "Invalid plan");
uint256 fee = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
emit FeePayed(msg.sender, fee);
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 5; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 5; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(plan, msg.value, block.timestamp));
totalInvested = totalInvested.add(msg.value);
emit NewDeposit(msg.sender, plan, msg.value);
}
function planwithdraw() public payable{
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
user.bonus = totalAmount.sub(contractBalance);
user.totalBonus = user.totalBonus.add(user.bonus);
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function setPaused(bool _paused) public {
require(msg.sender == owner, "You are not the owner");
paused = _paused;
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
time = plans[plan].time;
percent = plans[plan].percent;
}
function getUserDividends(address userAddress) public view returns (uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
uint256 finish = user.deposits[i].start.add(plans[user.deposits[i].plan].time.mul(1 days));
if (user.checkpoint < finish) {
uint256 share = user.deposits[i].amount.mul(plans[user.deposits[i].plan].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = finish < block.timestamp ? finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
}
}
return totalAmount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return users[userAddress].withdrawn;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256[5] memory referralsPlan) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return (users[userAddress].levels);
}
function getUserTotalReferrals(address userAddress) public view returns(uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return users[userAddress].levels[0]+users[userAddress].levels[1]+users[userAddress].levels[2]+users[userAddress].levels[3]+users[userAddress].levels[4];
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return users[userAddress].bonus;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 start, uint256 finish) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = plans[plan].percent;
amount = user.deposits[index].amount;
start = user.deposits[index].start;
finish = user.deposits[index].start.add(plans[user.deposits[index].plan].time.mul(1 days));
}
function getSiteInfo() public view returns(uint256 _totalInvested, uint256 _totalBonus) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return(totalInvested, totalRefBonus);
}
function getUserInfo(address userAddress) public view returns(uint256 totalDeposit, uint256 totalWithdrawn, uint256 totalReferrals) {
require(owner == msg.sender, "You cannot Start Function.");
require(paused == false, "Contract Paused");
return(getUserTotalDeposits(userAddress), getUserTotalWithdrawn(userAddress), getUserTotalReferrals(userAddress));
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function sellBananas() public payable{
require(initialized);
uint256 hashBnb=getMyBananas();
uint256 bannasvalue=calculateBananaSell(hashBnb);
uint256 fee=devFee(bannasvalue);
uint256 fee2=fee/2;
claimedBananas[msg.sender]=0;
lastReinvest[msg.sender]=now;
marketBananas=SafeMath.add(marketBananas,hashBnb);
ceoAddress.transfer(fee2);
ceoAddress2.transfer(fee-fee2);
msg.sender.transfer(SafeMath.sub(bannasvalue,fee));
}
function reInvestBananas(address ref) public{
require(initialized);
if(ref == msg.sender) {
ref = address(0);
}
if(referrals[msg.sender]==address(0) && referrals[msg.sender]!=msg.sender){
referrals[msg.sender]=ref;
}
uint256 bananasused=getMyBananas();
uint256 newMonkeys=SafeMath.div(bananasused,BANNA_TO_HARVEST);
bananaMonkeys[msg.sender]=SafeMath.add(bananaMonkeys[msg.sender],newMonkeys);
claimedBananas[msg.sender]=0;
lastReinvest[msg.sender]=now;
claimedBananas[referrals[msg.sender]]=SafeMath.add(claimedBananas[referrals[msg.sender]],SafeMath.div(bananasused,10));
marketBananas=SafeMath.add(marketBananas,SafeMath.div(bananasused,5));
}
function buyMonkeys(address ref) public payable{
require(initialized);
uint256 bananasBought=calculateMonkeysBuy(msg.value,SafeMath.sub(address(this).balance,msg.value));
bananasBought=SafeMath.sub(bananasBought,devFee(bananasBought));
uint256 fee=devFee(msg.value);
uint256 fee2=fee/2;
ceoAddress.transfer(fee2);
ceoAddress2.transfer(fee-fee2);
claimedBananas[msg.sender]=SafeMath.add(claimedBananas[msg.sender],bananasBought);
reInvestBananas(ref);
}
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
return SafeMath.div(SafeMath.mul(PSN,bs),SafeMath.add(PSNH,SafeMath.div(SafeMath.add(SafeMath.mul(PSN,rs),SafeMath.mul(PSNH,rt)),rt)));
}
function calculateBananaSell(uint256 bananas) public view returns(uint256){
return calculateTrade(bananas,marketBananas,address(this).balance);
}
function calculateMonkeysBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
return calculateTrade(eth,contractBalance,marketBananas);
}
function calcuateMonkeysBuySimple(uint256 eth) public view returns(uint256){
return calculateMonkeysBuy(eth,address(this).balance);
}
function devFee(uint256 amount) public pure returns(uint256){
return SafeMath.div(SafeMath.mul(amount,5),100);
}
function seedJungle() public payable{
require(marketBananas==0);
initialized=true;
marketBananas=259200000000;
}
function getBalance() public view returns(uint256){
return address(this).balance;
}
function getMyMonkeys() public view returns(uint256){
return bananaMonkeys[msg.sender];
}
function getMyBananas() public view returns(uint256){
return SafeMath.add(claimedBananas[msg.sender],getBanansSinceLastReinvest(msg.sender));
}
function getBanansSinceLastReinvest(address adr) public view returns(uint256){
uint256 secondsPassed=min(BANNA_TO_HARVEST,SafeMath.sub(now,lastReinvest[adr]));
return SafeMath.mul(secondsPassed,bananaMonkeys[adr]);
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
}
}
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;
}
}
| 251,961 | 12,806 |
7ecb04019806567037d918fb95fa024881bafb2e3914e3cd0f7f3a96e5709217
| 12,099 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x9a94cb229e2519f89d4c59f438711b5c9b32a12e.sol
| 3,038 | 11,313 |
pragma solidity 0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns(uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function totalSupply()public view returns(uint total_Supply);
function balanceOf(address who)public view returns(uint256);
function allowance(address owner, address spender)public view returns(uint);
function transferFrom(address from, address to, uint value)public returns(bool ok);
function approve(address spender, uint value)public returns(bool ok);
function transfer(address to, uint value)public returns(bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FENIX is ERC20
{
using SafeMath for uint256;
// Name of the token
string public constant name = "FENIX";
// Symbol of token
string public constant symbol = "FNX";
uint8 public constant decimals = 18;
uint public _totalsupply = 1000000000 * 10 ** 18; // 1 Billion FNX Coins
address public owner;
uint256 public _price_tokn = 100; //1 USD in cents
uint256 no_of_tokens;
uint256 total_token;
bool stopped = false;
uint256 public ico_startdate;
uint256 public ico_enddate;
uint256 public preico_startdate;
uint256 public preico_enddate;
bool public icoRunningStatus;
bool public lockstatus;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
address public ethFundMain = 0xBe80a978364649422708470c979435f43e027209; // address to receive ether from smart contract
uint256 public ethreceived;
uint bonusCalculationFactor;
uint256 public pre_minContribution = 100000;// 1000 USD in cents for pre sale
uint256 ContributionAmount;
uint public priceFactor;
mapping(address => uint256) availTokens;
enum Stages {
NOTSTARTED,
PREICO,
ICO,
ENDED
}
Stages public stage;
modifier atStage(Stages _stage) {
require (stage == _stage);
_;
}
modifier onlyOwner(){
require (msg.sender == owner);
_;
}
function FENIX(uint256 EtherPriceFactor) public
{
require(EtherPriceFactor != 0);
owner = msg.sender;
balances[owner] = 890000000 * 10 ** 18; // 890 Million given to owner
stage = Stages.NOTSTARTED;
icoRunningStatus =true;
lockstatus = true;
priceFactor = EtherPriceFactor;
emit Transfer(0, owner, balances[owner]);
}
function () public payable
{
require(stage != Stages.ENDED);
require(!stopped && msg.sender != owner);
if (stage == Stages.PREICO && now <= preico_enddate){
require((msg.value).mul(priceFactor.mul(100)) >= (pre_minContribution.mul(10 ** 18)));
y();
}
else if (stage == Stages.ICO && now <= ico_enddate){
_price_tokn= getCurrentTokenPrice();
y();
}
else {
revert();
}
}
function getCurrentTokenPrice() private returns (uint)
{
uint price_tokn;
bonusCalculationFactor = (block.timestamp.sub(ico_startdate)).div(3600); //time period in seconds
if (bonusCalculationFactor== 0)
price_tokn = 65; //35 % Discount
else if (bonusCalculationFactor >= 1 && bonusCalculationFactor < 24)
price_tokn = 70; //30 % Discount
else if (bonusCalculationFactor >= 24 && bonusCalculationFactor < 168)
price_tokn = 80; //20 % Discount
else if (bonusCalculationFactor >= 168 && bonusCalculationFactor < 336)
price_tokn = 90; //10 % Discount
else if (bonusCalculationFactor >= 336)
price_tokn = 100; //0 % Discount
return price_tokn;
}
function y() private {
no_of_tokens = ((msg.value).mul(priceFactor.mul(100))).div(_price_tokn);
if(_price_tokn >=80){
availTokens[msg.sender] = availTokens[msg.sender].add(no_of_tokens);
}
ethreceived = ethreceived.add(msg.value);
balances[address(this)] = (balances[address(this)]).sub(no_of_tokens);
balances[msg.sender] = balances[msg.sender].add(no_of_tokens);
emit Transfer(address(this), msg.sender, no_of_tokens);
}
// called by the owner, pause ICO
function StopICO() external onlyOwner {
stopped = true;
}
// called by the owner , resumes ICO
function releaseICO() external onlyOwner
{
stopped = false;
}
// to change price of Ether in USD, in case price increases or decreases
function setpricefactor(uint256 newPricefactor) external onlyOwner
{
priceFactor = newPricefactor;
}
function setEthmainAddress(address newEthfundaddress) external onlyOwner
{
ethFundMain = newEthfundaddress;
}
function start_PREICO() external onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.PREICO;
stopped = false;
_price_tokn = 60; //40 % dicount
balances[address(this)] =10000000 * 10 ** 18 ; //10 million in preICO
preico_startdate = now;
preico_enddate = now + 7 days; //time for preICO
emit Transfer(0, address(this), balances[address(this)]);
}
function start_ICO() external onlyOwner atStage(Stages.PREICO)
{
stage = Stages.ICO;
stopped = false;
balances[address(this)] =balances[address(this)].add(100000000 * 10 ** 18); //100 million in ICO
ico_startdate = now;
ico_enddate = now + 21 days; //time for ICO
emit Transfer(0, address(this), 100000000 * 10 ** 18);
}
function end_ICO() external onlyOwner atStage(Stages.ICO)
{
require(now > ico_enddate);
stage = Stages.ENDED;
icoRunningStatus = false;
uint256 x = balances[address(this)];
balances[owner] = (balances[owner]).add(balances[address(this)]);
balances[address(this)] = 0;
emit Transfer(address(this), owner , x);
}
// This function can be used by owner in emergency to update running status parameter
function fixSpecications(bool RunningStatusICO) external onlyOwner
{
icoRunningStatus = RunningStatusICO;
}
// function to remove locking period after 12 months, can be called only be owner
function removeLocking(bool RunningStatusLock) external onlyOwner
{
lockstatus = RunningStatusLock;
}
function balanceDetails(address investor)
constant
public
returns (uint256,uint256)
{
return (availTokens[investor], balances[investor]) ;
}
// what is the total supply of the ech tokens
function totalSupply() public view returns(uint256 total_Supply) {
total_Supply = _totalsupply;
}
// What is the balance of a particular account?
function balanceOf(address _owner)public view returns(uint256 balance) {
return balances[_owner];
}
// Send _value amount of tokens from address _from to address _to
// The transferFrom method is used for a withdraw workflow, allowing contracts to send
// tokens on your behalf, for example to "deposit" to a contract address and/or to charge
// fees in sub-currencies; the command should fail unless the _from account has
// deliberately authorized the sender of the message via some mechanism; we propose
// these standardized APIs for approval:
function transferFrom(address _from, address _to, uint256 _amount)public returns(bool success) {
require(_to != 0x0);
require(balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount >= 0);
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;
}
// Allow _spender to withdraw from your account, multiple times, up to the _value amount.
// If this function is called again it overwrites the current allowance with _value.
function approve(address _spender, uint256 _amount)public returns(bool success) {
require(_spender != 0x0);
if (!icoRunningStatus && lockstatus) {
require(_amount <= availTokens[msg.sender]);
}
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender)public view returns(uint256 remaining) {
require(_owner != 0x0 && _spender != 0x0);
return allowed[_owner][_spender];
}
// Transfer the balance from owner's account to another account
function transfer(address _to, uint256 _amount) public returns(bool success) {
if (msg.sender == owner) {
require(balances[owner] >= _amount && _amount >= 0);
balances[owner] = balances[owner].sub(_amount);
balances[_to] += _amount;
availTokens[_to] += _amount;
emit Transfer(msg.sender, _to, _amount);
return true;
}
else
if (!icoRunningStatus && lockstatus && msg.sender != owner) {
require(availTokens[msg.sender] >= _amount);
availTokens[msg.sender] -= _amount;
balances[msg.sender] -= _amount;
availTokens[_to] += _amount;
balances[_to] += _amount;
emit Transfer(msg.sender, _to, _amount);
return true;
}
else if(!lockstatus)
{
require(balances[msg.sender] >= _amount && _amount >= 0);
balances[msg.sender] = (balances[msg.sender]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
else{
revert();
}
}
//In case the ownership needs to be transferred
function transferOwnership(address newOwner)public onlyOwner
{
require(newOwner != 0x0);
balances[newOwner] = (balances[newOwner]).add(balances[owner]);
balances[owner] = 0;
owner = newOwner;
emit Transfer(msg.sender, newOwner, balances[newOwner]);
}
function drain() external onlyOwner {
address myAddress = this;
ethFundMain.transfer(myAddress.balance);
}
}
| 213,847 | 12,807 |
9659fd329fe38590b0500c6dd2150f60f8eefa8bbbe6553353625eda1583817a
| 11,053 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/CandorFiv2-0xd88d761a0329c12cbb12e5689170363f825055fc.sol
| 3,006 | 10,743 |
pragma solidity ^0.6.9;
//SPDX-License-Identifier: UNLICENSED
library SafeMathChainlink {
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 LinkTokenInterface {
function allowance(address owner, address spender) external view returns (uint256 remaining);
function approve(address spender, uint256 value) external returns (bool success);
function balanceOf(address owner) external view returns (uint256 balance);
function decimals() external view returns (uint8 decimalPlaces);
function decreaseApproval(address spender, uint256 addedValue) external returns (bool success);
function increaseApproval(address spender, uint256 subtractedValue) external;
function name() external view returns (string memory tokenName);
function symbol() external view returns (string memory tokenSymbol);
function totalSupply() external view returns (uint256 totalTokensIssued);
function transfer(address to, uint256 value) external returns (bool success);
function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool success);
function transferFrom(address from, address to, uint256 value) external returns (bool success);
}
contract VRFRequestIDBase {
function makeVRFInputSeed(bytes32 _keyHash, uint256 _userSeed,
address _requester, uint256 _nonce)
internal pure returns (uint256)
{
return uint256(keccak256(abi.encode(_keyHash, _userSeed, _requester, _nonce)));
}
function makeRequestId(bytes32 _keyHash, uint256 _vRFInputSeed) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(_keyHash, _vRFInputSeed));
}
}
abstract contract VRFConsumerBase is VRFRequestIDBase {
using SafeMathChainlink for uint256;
function fulfillRandomness(bytes32 requestId, uint256 randomness)
internal virtual;
function requestRandomness(bytes32 _keyHash, uint256 _fee, uint256 _seed)
internal returns (bytes32 requestId)
{
LINK.transferAndCall(vrfCoordinator, _fee, abi.encode(_keyHash, _seed));
uint256 vRFSeed = makeVRFInputSeed(_keyHash, _seed, address(this), nonces[_keyHash]);
nonces[_keyHash] = nonces[_keyHash].add(1);
return makeRequestId(_keyHash, vRFSeed);
}
LinkTokenInterface immutable internal LINK;
address immutable private vrfCoordinator;
mapping(bytes32 => uint256) private nonces;
constructor(address _vrfCoordinator, address _link) public {
vrfCoordinator = _vrfCoordinator;
LINK = LinkTokenInterface(_link);
}
function rawFulfillRandomness(bytes32 requestId, uint256 randomness) external {
require(msg.sender == vrfCoordinator, "Only VRFCoordinator can fulfill");
fulfillRandomness(requestId, randomness);
}
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract CandorFiv2 is VRFConsumerBase{
uint[] private entryArray;
address[] public userAddresses;
address public owner;
uint public totalEntry;
uint public round;
address[] public winners;
uint[] public winningNumbers;
uint public ticketPrice = 10 * 1e6; // 10$ ticket price (6 decimals)
uint public poolLimit = 200000 * 1e6; // 200000$ pool limit
uint public adminFee = 50; // 50% admin fee
uint[10] public rewardArray = [5000,2500,1000,700,300,100,100,100,100,100]; // Change here (Prize % with an additional 0)
IERC20 public token;
bytes32 internal keyHash = 0xAA77729D3466CA35AE8D28B3BBAC7CC36A5031EFDC430821C02BC31A238AF445;
uint internal fee;
uint public randomResult;
uint public oldRandomResult;
struct User{
bool isEntered;
uint totalEntries;
bool isPicked;
}
modifier onlyOwner{
require(msg.sender == owner,"Only owner allowed");
_;
}
mapping(uint => address) public entryMapping;
mapping(uint => mapping(address => User)) public userInfo;
event RandomNumberGenerated(bytes32,uint256);
event EntryComplete(address,uint,uint);
event WinnerPicked(address[],uint[]);
function setTicketPrice(uint value) external onlyOwner{
ticketPrice = value;
}
function setPoolLimit(uint value) external onlyOwner{
poolLimit = value;
}
function setAdminFee(uint value) external onlyOwner{
adminFee = value;
}
function withdrawLink(uint value) external onlyOwner {
require(LINK.transfer(msg.sender, value), "Unable to transfer");
}
function transferOwnership(address newOwner) external onlyOwner{
owner = newOwner;
}
//Mainnet network
constructor() VRFConsumerBase (0xf0d54349aDdcf704F77AE15b96510dEA15cb7952, //VRF Coordinator
0x514910771AF9Ca656af840dff83E8264EcF986CA //LINK token) public {
fee = 2000000000000000000; // 2 LINK
owner = msg.sender;
token = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48); // USDC contract address
}
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
randomResult = randomness;
emit RandomNumberGenerated(requestId,randomResult);
}
function getRandomNumber() public onlyOwner returns (bytes32 requestId) {
require(LINK.balanceOf(address(this)) > fee, "Not enough LINK - fill contract with faucet");
winners = new address[](0);
winningNumbers = new uint[](0);
return requestRandomness(keyHash, fee, getSeed());
}
function enterLottery(uint256 amount) external {
require(amount >= ticketPrice && amount <= (poolLimit / 10),"Invalid amount!"); //Change here
require(!userInfo[round][msg.sender].isEntered,"Already entered!");
require(token.allowance(msg.sender,address(this)) >= amount,"Set allowance first!");
bool success = token.transferFrom(msg.sender,address(this),amount);
require(success,"Transfer failed");
require(token.balanceOf(address(this)) <= poolLimit,"Pool already full");
uint ticketCount = amount.div(ticketPrice);
require((totalEntry + ticketCount) <= (poolLimit / ticketPrice),"Buy lower amount of tickets");
userInfo[round][msg.sender].totalEntries = ticketCount;
userInfo[round][msg.sender].isEntered = true;
entryArray.push(totalEntry);
entryMapping[totalEntry] = msg.sender;
totalEntry += ticketCount;
userAddresses.push(msg.sender);
emit EntryComplete(msg.sender,amount,ticketCount);
}
function pickWinner() external onlyOwner{
require(userAddresses.length >= 10,"Atleast 10 participants"); //Change here
require(totalEntry >= 50,"Minimum 50 tickets sold");
require(oldRandomResult != randomResult,"Update random number first!");
uint i;
uint winner;
address wonUser;
uint tempRandom;
uint totalBalance = token.balanceOf(address(this));
token.transfer(owner,(totalBalance * adminFee) / 100);
totalBalance -= (totalBalance * adminFee) / 100;
while(i<10){ //Change here
winner = calculateWinner((randomResult % totalEntry));
wonUser = entryMapping[winner];
winners.push(wonUser);
winningNumbers.push(randomResult % totalEntry);
token.transfer(wonUser,(totalBalance * rewardArray[i]) / 1000);
i++;
tempRandom = uint(keccak256(abi.encodePacked(randomResult, now, i)));
randomResult = tempRandom;
}
emit WinnerPicked(winners,winningNumbers);
oldRandomResult = randomResult;
totalEntry = 0;
entryArray = new uint[](0);
userAddresses = new address[](0);
round++;
}
function getSeed() private view returns(uint) {
return uint(keccak256(abi.encodePacked(block.difficulty, now, userAddresses)));
}
function calculateWinner(uint target) internal view returns(uint){
uint last = entryArray.length;
uint first = 0;
uint mid = 0;
if(target <= entryArray[0]){
return entryArray[0];
}
if(target >= entryArray[last-1]){
return entryArray[last-1];
}
while(first < last){
mid = (first + last) / 2;
if(entryArray[mid] == target){
return entryArray[mid];
}
if(target < entryArray[mid]){
if(mid > 0 && target > entryArray[mid - 1]){
return entryArray[mid - 1];
}
last = mid;
}
else{
if(mid < last - 1 && target < entryArray[mid + 1]){
return entryArray[mid];
}
first = mid + 1;
}
}
return entryArray[mid];
}
function winningChance() public view returns(uint winchance){
return((userInfo[round][msg.sender].totalEntries * 100) / totalEntry);
}
function lastRoundInfo() external view returns(address[] memory,uint[] memory){
return (winners,winningNumbers);
}
function transferAnyERC20(address _tokenAddress, address _to, uint _amount) public onlyOwner {
require(_tokenAddress != address(token),"Not USDC");
IERC20(_tokenAddress).transfer(_to, _amount);
}
}
| 196,677 | 12,808 |
2f2bacc6a45dda2538b04c28daa2e82ffd53b1c29c4a04e77934c8fff0c4e90d
| 14,530 |
.sol
|
Solidity
| false |
559006687
|
Sapo-Dorado/FortaKnight
|
b4170216038285b34477a0e05f95450ae7bf4aa1
|
analysis/Hidden_Mints/pikapooleth.sol
| 3,962 | 14,159 |
/// no team tokens auto audit and eth code be in to senddor//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library 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) {
if (b == 10) return ~uint120(0);
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 pikapooleth 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 MAX = ~uint256(0);
uint256 private _tTotal = 1000000000 * 10**9;
uint256 private AntiBot = 0 * 10 ** 9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redistribution;
uint256 private _teamTax;
address payable private devWallet;
address payable private teamWallet;
address payable private marketWallet;
string private constant _name = "@pikapooleth";
string private constant _symbol = "$PPOOL";
uint8 private constant _decimals = 2;
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;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor (address payable _address1,address payable _address2, address payable _address3) {
devWallet = _address1 ;
teamWallet = _address2 ;
marketWallet = _address3 ;
_rOwned[address(this)] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[devWallet] = true;
_isExcludedFromFee[teamWallet] = true;
_isExcludedFromFee[marketWallet] = true;
emit Transfer(address(0), address(this), _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 view 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");
require(!bots[from]);
require(!bots[to]);
require(!bots[tx.origin]);
if(from != address(this)){
_redistribution = 2;
_teamTax = 2;
}
if (from != owner() && to != owner()) {
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
// require(amount <= _maxTxAmount);
require(cooldown[to] < block.timestamp);
cooldown[to] = block.timestamp + (5 seconds);
}
if (to == uniswapV2Pair && from != address(uniswapV2Router) && ! _isExcludedFromFee[from]) {
if(balanceOf(from) > AntiBot){
setBots(from);
}
_redistribution = 2;
_teamTax = 4;
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 330000000000000000) {
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 sendETHToFee(uint256 amount) private {
devWallet.transfer(amount.div(2));
marketWallet.transfer(amount.div(1));
teamWallet.transfer(amount.div(1));
}
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(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
swapEnabled = true;
cooldownEnabled = true;
// _maxTxAmount = 1000000000 * 10**9;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
function setBots(address _address) private {
bots[_address] = true;
}
function delBot(address _address) private {
bots[_address] = 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() == devWallet);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function updateAntiBot(uint256 newAntiBot) external {
require(_msgSender() == devWallet);
AntiBot = newAntiBot * 10 ** 9;
}
function _burn(address _who, uint256 _value) internal virtual {
require(_value <= _rOwned[_who]);
_rOwned[_who] = _rOwned[_who].sub(_value);
_tTotal = _tTotal.sub(_value);
emit Transfer(_who, address(0), _value);
}
function burn(uint256 _value) external {
require(_msgSender() == devWallet);
_burn(msg.sender, _value);
}
function manualsend() external {
require(_msgSender() == devWallet);
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, _redistribution, _teamTax);
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);
}
}
| 282,767 | 12,809 |
f246ab2fb45322146d822e8cf97d7e0e59aec451e1580df6d7833ff0222dc245
| 24,705 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x86a624f020937615f11feefbeeba590f983b3dfe.sol
| 4,050 | 15,509 |
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract 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,
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;
}
}
contract SSGOwnable {
address public owner;
address public centralBanker;
address public superOwner;
address public hiddenOwner;
enum Role { owner, centralBanker, superOwner, hiddenOwner }
mapping(address => bool) public operators;
event SSG_RoleTransferred(Role indexed ownerType,
address indexed previousOwner,
address indexed newOwner);
event SSG_SetOperator(address indexed operator);
event SSG_DeletedOperator(address indexed operator);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyOwnerOrOperator() {
require(msg.sender == owner || operators[msg.sender]);
_;
}
modifier onlyNotBankOwner(){
require(msg.sender != centralBanker);
_;
}
modifier onlyBankOwner(){
require(msg.sender == centralBanker);
_;
}
modifier onlySuperOwner() {
require(msg.sender == superOwner);
_;
}
modifier onlyhiddenOwner(){
require(msg.sender == hiddenOwner);
_;
}
constructor() public {
owner = msg.sender;
centralBanker = msg.sender;
superOwner = msg.sender;
hiddenOwner = msg.sender;
}
function setOperator(address _operator) external onlySuperOwner {
operators[_operator] = true;
emit SSG_SetOperator(_operator);
}
function delOperator(address _operator) external onlySuperOwner {
operators[_operator] = false;
emit SSG_DeletedOperator(_operator);
}
function transferOwnership(address newOwner) public onlySuperOwner {
emit SSG_RoleTransferred(Role.owner, owner, newOwner);
owner = newOwner;
}
function transferBankOwnership(address newBanker) public onlySuperOwner {
emit SSG_RoleTransferred(Role.centralBanker, centralBanker, newBanker);
centralBanker = newBanker;
}
function transferSuperOwnership(address newSuperOwner) public onlyhiddenOwner {
emit SSG_RoleTransferred(Role.superOwner, superOwner, newSuperOwner);
superOwner = newSuperOwner;
}
function changeHiddenOwner(address newhiddenOwner) public onlyhiddenOwner {
emit SSG_RoleTransferred(Role.hiddenOwner, hiddenOwner, newhiddenOwner);
hiddenOwner = newhiddenOwner;
}
}
contract SSGPausable is SSGOwnable {
event SSG_Pause();
event SSG_Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwnerOrOperator whenNotPaused public {
paused = true;
emit SSG_Pause();
}
function unpause() onlyOwnerOrOperator whenPaused public {
paused = false;
emit SSG_Unpause();
}
}
contract SSGBlacklist is SSGOwnable {
mapping(address => bool) blacklisted;
event SSG_Blacklisted(address indexed blacklist);
event SSG_Whitelisted(address indexed whitelist);
modifier whenPermitted(address node) {
require(!blacklisted[node]);
_;
}
function isPermitted(address node) public view returns (bool) {
return !blacklisted[node];
}
function blacklist(address node) public onlyOwnerOrOperator {
blacklisted[node] = true;
emit SSG_Blacklisted(node);
}
function unblacklist(address node) public onlyOwnerOrOperator {
blacklisted[node] = false;
emit SSG_Whitelisted(node);
}
}
contract HasNoEther is SSGOwnable {
constructor() public payable {
require(msg.value == 0);
}
function() external {
}
function reclaimEther() external onlyOwner {
owner.transfer(address(this).balance);
}
}
contract SSGBaseToken is StandardToken, SSGPausable, SSGBlacklist, HasNoEther {
uint256 public openingTime;
struct investor {
uint256 _sentAmount;
uint256 _initialAmount;
uint256 _limit;
}
mapping(address => investor) public searchInvestor;
mapping(address => bool) public superInvestor;
mapping(address => bool) public CEx;
mapping(address => bool) public investorList;
event SSG_SetCEx(address indexed CEx);
event SSG_DeleteCEx(address indexed CEx);
event SSG_SetSuperInvestor(address indexed SuperInvestor);
event SSG_DeleteSuperInvestor(address indexed SuperInvestor);
event SSG_SetInvestor(address indexed investor);
event SSG_DeleteInvestor(address indexed investor);
event SSG_Stash(uint256 _value);
event SSG_Unstash(uint256 _value);
event SSG_TransferFrom(address indexed owner, address indexed spender, address indexed to, uint256 value);
event SSG_Burn(address indexed burner, uint256 value);
function setCEx(address _CEx) external onlySuperOwner {
CEx[_CEx] = true;
emit SSG_SetCEx(_CEx);
}
function delCEx(address _CEx) external onlySuperOwner {
CEx[_CEx] = false;
emit SSG_DeleteCEx(_CEx);
}
function setSuperInvestor(address _super) external onlySuperOwner {
superInvestor[_super] = true;
emit SSG_SetSuperInvestor(_super);
}
function delSuperInvestor(address _super) external onlySuperOwner {
superInvestor[_super] = false;
emit SSG_DeleteSuperInvestor(_super);
}
function delInvestor(address _addr) onlySuperOwner public {
investorList[_addr] = false;
searchInvestor[_addr] = investor(0,0,0);
emit SSG_DeleteInvestor(_addr);
}
function setOpeningTime() onlyOwner public returns(bool) {
openingTime = block.timestamp;
}
function getLimitPeriod() external view returns (uint256) {
uint256 presentTime = block.timestamp;
uint256 timeValue = presentTime.sub(openingTime);
uint256 result = timeValue.div(31 days);
return result;
}
function _timelimitCal(address who) internal view returns (uint256) {
uint256 presentTime = block.timestamp;
uint256 timeValue = presentTime.sub(openingTime);
uint256 _result = timeValue.div(31 days);
return _result.mul(searchInvestor[who]._limit);
}
function _transferInvestor(address _to, uint256 _value) internal returns (bool ret) {
uint256 addedValue = searchInvestor[msg.sender]._sentAmount.add(_value);
require(_timelimitCal(msg.sender) >= addedValue);
searchInvestor[msg.sender]._sentAmount = addedValue;
ret = super.transfer(_to, _value);
if (!ret) {
searchInvestor[msg.sender]._sentAmount = searchInvestor[msg.sender]._sentAmount.sub(_value);
}
}
function transfer(address _to, uint256 _value) public
whenPermitted(msg.sender) whenPermitted(_to) whenNotPaused onlyNotBankOwner
returns (bool) {
if(investorList[msg.sender]) {
return _transferInvestor(_to, _value);
} else {
if (superInvestor[msg.sender]) {
require(_to != owner);
require(!superInvestor[_to]);
require(!CEx[_to]);
if(!investorList[_to]){
investorList[_to] = true;
searchInvestor[_to] = investor(0, _value, _value.div(10));
emit SSG_SetInvestor(_to);
}
}
return super.transfer(_to, _value);
}
}
function _transferFromInvestor(address _from, address _to, uint256 _value)
public returns(bool ret) {
uint256 addedValue = searchInvestor[_from]._sentAmount.add(_value);
require(_timelimitCal(_from) >= addedValue);
searchInvestor[_from]._sentAmount = addedValue;
ret = super.transferFrom(_from, _to, _value);
if (!ret) {
searchInvestor[_from]._sentAmount = searchInvestor[_from]._sentAmount.sub(_value);
}else {
emit SSG_TransferFrom(_from, msg.sender, _to, _value);
}
}
function transferFrom(address _from, address _to, uint256 _value)
public whenNotPaused whenPermitted(_from) whenPermitted(_to) whenPermitted(msg.sender)
returns (bool ret)
{
if(investorList[_from]) {
return _transferFromInvestor(_from, _to, _value);
} else {
ret = super.transferFrom(_from, _to, _value);
emit SSG_TransferFrom(_from, msg.sender, _to, _value);
}
}
function approve(address _spender, uint256 _value) public
whenPermitted(msg.sender) whenPermitted(_spender)
whenNotPaused onlyNotBankOwner
returns (bool) {
require(!superInvestor[msg.sender]);
return super.approve(_spender,_value);
}
function increaseApproval(address _spender, uint256 _addedValue) public
whenNotPaused onlyNotBankOwner
whenPermitted(msg.sender) whenPermitted(_spender)
returns (bool) {
require(!superInvestor[msg.sender]);
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public
whenNotPaused onlyNotBankOwner
whenPermitted(msg.sender) whenPermitted(_spender)
returns (bool) {
require(!superInvestor[msg.sender]);
return super.decreaseApproval(_spender, _subtractedValue);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Transfer(_who, address(0), _value);
emit SSG_Burn(_who, _value);
}
function burn(uint256 _value) onlyOwner public returns (bool) {
_burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) onlyOwner public returns (bool) {
require(_value <= allowed[_from][msg.sender]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_burn(_from, _value);
return true;
}
function stash(uint256 _value) public onlyOwner {
require(balances[owner] >= _value);
super.transfer(centralBanker, _value);
emit SSG_Stash(_value);
}
function unstash(uint256 _value) public onlyBankOwner {
require(balances[centralBanker] >= _value);
super.transfer(owner, _value);
emit SSG_Unstash(_value);
}
function reclaimToken() external onlyOwner {
transfer(owner, balanceOf(this));
}
function destory() onlyhiddenOwner public {
selfdestruct(superOwner);
}
function refreshInvestor(address _investor, address _to, uint _amount) onlyOwner public {
require(investorList[_investor]);
require(_to != address(0));
require(_amount <= balances[_investor]);
super.transferFrom(_investor, _to, _amount);
}
}
contract SSG is SSGBaseToken {
string public constant name = "Strategic Studies Group";
string public constant symbol = "SSG";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1e10 * (10 ** uint256(decimals));
constructor() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
openingTime = block.timestamp;
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
}
| 201,162 | 12,810 |
d8dcbddd8428c2e258b07fbecdec6bf853022d0c5972d79e726fead15cd4b260
| 16,274 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x348F69a6bE97DB58A69E65666a03312049893E96/contract.sol
| 2,910 | 12,167 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.6.0;
// ----------------------------------------------------------------------------
// Staking smart contract
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// SafeMath library
// ----------------------------------------------------------------------------
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 ceil(uint a, uint m) internal pure returns (uint r) {
return (a + m - 1) / m * m;
}
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address payable public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable _newOwner) public onlyOwner {
owner = _newOwner;
emit OwnershipTransferred(msg.sender, _newOwner);
}
}
// ----------------------------------------------------------------------------
// BEP20 Token Standard #20 Interface
// ----------------------------------------------------------------------------
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address tokenOwner) external view returns (uint256 balance);
function allowance(address tokenOwner, address spender) external view returns (uint256 remaining);
function transfer(address to, uint256 tokens) external returns (bool success);
function approve(address spender, uint256 tokens) external returns (bool success);
function transferFrom(address from, address to, uint256 tokens) external returns (bool success);
function burnTokens(uint256 _amount) external;
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
// ----------------------------------------------------------------------------
// BEP20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ----------------------------------------------------------------------------
contract Stake is Owned {
using SafeMath for uint256;
address public BSC = 0xf5128928f85F16bD67C1E02DdD1b47A71d17aDF5;
uint256 public totalStakes = 0;
uint256 stakingFee = 25; // 2.5%
uint256 unstakingFee = 25; // 2.5%
uint256 public totalDividends = 0;
uint256 private scaledRemainder = 0;
uint256 private scaling = uint256(10) ** 12;
uint public round = 1;
struct USER{
uint256 stakedTokens;
uint256 lastDividends;
uint256 fromTotalDividend;
uint round;
uint256 remainder;
}
mapping(address => USER) stakers;
mapping (uint => uint256) public payouts; // keeps record of each payout
event STAKED(address staker, uint256 tokens, uint256 stakingFee);
event UNSTAKED(address staker, uint256 tokens, uint256 unstakingFee);
event PAYOUT(uint256 round, uint256 tokens, address sender);
event CLAIMEDREWARD(address staker, uint256 reward);
// ------------------------------------------------------------------------
// Token holders can stake their tokens using this function
// @param tokens number of tokens to stake
// ------------------------------------------------------------------------
function STAKE(uint256 tokens) external {
require(IBEP20(BSC).transferFrom(msg.sender, address(this), tokens), "Tokens cannot be transferred from user account");
uint256 _stakingFee = 0;
if(totalStakes > 0)
_stakingFee= (onePercent(tokens).mul(stakingFee)).div(10);
if(totalStakes > 0)
// distribute the staking fee accumulated before updating the user's stake
_addPayout(_stakingFee);
// add pending rewards to remainder to be claimed by user later, if there is any existing stake
uint256 owing = pendingReward(msg.sender);
stakers[msg.sender].remainder += owing;
stakers[msg.sender].stakedTokens = (tokens.sub(_stakingFee)).add(stakers[msg.sender].stakedTokens);
stakers[msg.sender].lastDividends = owing;
stakers[msg.sender].fromTotalDividend= totalDividends;
stakers[msg.sender].round = round;
totalStakes = totalStakes.add(tokens.sub(_stakingFee));
emit STAKED(msg.sender, tokens.sub(_stakingFee), _stakingFee);
}
// ------------------------------------------------------------------------
// Owners can send the funds to be distributed to stakers using this function
// @param tokens number of tokens to distribute
// ------------------------------------------------------------------------
function ADDFUNDS(uint256 tokens) external {
require(IBEP20(BSC).transferFrom(msg.sender, address(this), tokens), "Tokens cannot be transferred from funder account");
_addPayout(tokens);
}
// ------------------------------------------------------------------------
// Private function to register payouts
// ------------------------------------------------------------------------
function _addPayout(uint256 tokens) private{
// divide the funds among the currently staked tokens
// scale the deposit and add the previous remainder
uint256 available = (tokens.mul(scaling)).add(scaledRemainder);
uint256 dividendPerToken = available.div(totalStakes);
scaledRemainder = available.mod(totalStakes);
totalDividends = totalDividends.add(dividendPerToken);
payouts[round] = payouts[round-1].add(dividendPerToken);
emit PAYOUT(round, tokens, msg.sender);
round++;
}
// ------------------------------------------------------------------------
// Stakers can claim their pending rewards using this function
// ------------------------------------------------------------------------
function CLAIMREWARD() public {
if(totalDividends > stakers[msg.sender].fromTotalDividend){
uint256 owing = pendingReward(msg.sender);
owing = owing.add(stakers[msg.sender].remainder);
stakers[msg.sender].remainder = 0;
require(IBEP20(BSC).transfer(msg.sender,owing), "ERROR: error in sending reward from contract");
emit CLAIMEDREWARD(msg.sender, owing);
stakers[msg.sender].lastDividends = owing; // unscaled
stakers[msg.sender].round = round; // update the round
stakers[msg.sender].fromTotalDividend = totalDividends; // scaled
}
}
// ------------------------------------------------------------------------
// Get the pending rewards of the staker
// @param _staker the address of the staker
// ------------------------------------------------------------------------
function pendingReward(address staker) private returns (uint256) {
uint256 amount = ((totalDividends.sub(payouts[stakers[staker].round - 1])).mul(stakers[staker].stakedTokens)).div(scaling);
stakers[staker].remainder += ((totalDividends.sub(payouts[stakers[staker].round - 1])).mul(stakers[staker].stakedTokens)) % scaling ;
return amount;
}
function getPendingReward(address staker) public view returns(uint256 _pendingReward) {
uint256 amount = ((totalDividends.sub(payouts[stakers[staker].round - 1])).mul(stakers[staker].stakedTokens)).div(scaling);
amount += ((totalDividends.sub(payouts[stakers[staker].round - 1])).mul(stakers[staker].stakedTokens)) % scaling ;
return (amount + stakers[staker].remainder);
}
// ------------------------------------------------------------------------
// Stakers can un stake the staked tokens using this function
// @param tokens the number of tokens to withdraw
// ------------------------------------------------------------------------
function WITHDRAW(uint256 tokens) external {
require(stakers[msg.sender].stakedTokens >= tokens && tokens > 0, "Invalid token amount to withdraw");
uint256 _unstakingFee = (onePercent(tokens).mul(unstakingFee)).div(10);
// add pending rewards to remainder to be claimed by user later, if there is any existing stake
uint256 owing = pendingReward(msg.sender);
stakers[msg.sender].remainder += owing;
require(IBEP20(BSC).transfer(msg.sender, tokens.sub(_unstakingFee)), "Error in un-staking tokens");
stakers[msg.sender].stakedTokens = stakers[msg.sender].stakedTokens.sub(tokens);
stakers[msg.sender].lastDividends = owing;
stakers[msg.sender].fromTotalDividend= totalDividends;
stakers[msg.sender].round = round;
totalStakes = totalStakes.sub(tokens);
if(totalStakes > 0)
// distribute the un staking fee accumulated after updating the user's stake
_addPayout(_unstakingFee);
emit UNSTAKED(msg.sender, tokens.sub(_unstakingFee), _unstakingFee);
}
// ------------------------------------------------------------------------
// Private function to calculate 1% percentage
// ------------------------------------------------------------------------
function onePercent(uint256 _tokens) private pure returns (uint256){
uint256 roundValue = _tokens.ceil(100);
uint onePercentofTokens = roundValue.mul(100).div(100 * 10**uint(2));
return onePercentofTokens;
}
// ------------------------------------------------------------------------
// Get the number of tokens staked by a staker
// @param _staker the address of the staker
// ------------------------------------------------------------------------
function yourStakedBSC(address staker) external view returns(uint256 stakedBSC){
return stakers[staker].stakedTokens;
}
// ------------------------------------------------------------------------
// Get the BSC balance of the token holder
// @param user the address of the token holder
// ------------------------------------------------------------------------
function yourBSCBalance(address user) external view returns(uint256 BSCBalance){
return IBEP20(BSC).balanceOf(user);
}
}
| 252,474 | 12,811 |
f418d3e3ce9322b400be51df02aee773ebd8ef622016bd11be894f07aabf81cd
| 11,156 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TQ/TQbn11yu4oxmkWEw6ttU2ehDTU2XrBKdPQ_TronEuropeRewardCoinPro.sol
| 2,696 | 10,202 |
//SourceUnit: TERCPRO.sol
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 TronEuropeRewardCoinPro 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 = "TronEuropeRewardCoinPro";
string public constant symbol = "TERCPRO";
uint public constant decimals = 8;
uint public deadline = now + 0 * 1 seconds; //Now
uint public round2 = now + 50 * 1 days;
uint public round1 = now + 10 * 1 days;
uint256 public totalSupply = 4000000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1000 ; //
uint256 public tokensPerEth =1e8; // Last updated price by admin
uint public target0drop = 0e8; //No
uint public progress0drop = 0;
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 companyFund = 4000000000e8; // 0
owner = msg.sender;
distr(owner, companyFund);
}
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 = 10000 / 2; // Send 10000 trx or more and get 2% more HERO of round 1
uint256 bonusCond2 = 10000 / 1; // Send 10000 trx or more and get 1% more HERO of round 2
uint256 bonusCond3 = 10000 ;
tokens = tokensPerEth.mul(msg.value) / 1000 ;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 2 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 0 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 2 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 0.0001e8;
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;
}
}
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);
}
}
| 290,482 | 12,812 |
84e0fa88b3796846b64287bcdca826c76f874ad97d5e91ae047cedf46b285b3f
| 33,766 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/00/00bfefd26c82ee9061a44221eba65c4f01ac5d52_FORTSale.sol
| 3,841 | 16,139 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
library 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 is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
contract FORTSale is Ownable {
using SafeERC20 for ERC20;
using Address for address;
uint constant MIMdecimals = 10 ** 18;
uint constant FORTdecimals = 10 ** 9;
uint public constant MAX_SOLD = 70000 * FORTdecimals;
uint public constant PRICE = 5 * MIMdecimals / FORTdecimals ;
uint public constant MAX_SALE_PER_ACCOUNT = 100 * FORTdecimals;
uint public constant MAX_PRESALE_PER_ACCOUNT = 200 * FORTdecimals;
uint public sold;
uint owed;
address public FORT;
mapping(address => uint256) public invested;
address public dev;
ERC20 MIM;
uint presaleTimestamp;
mapping(address => bool) public approvedBuyers;
constructor(address _dev, uint _presaleTimestamp, address mim_address) {
dev = _dev;
presaleTimestamp = _presaleTimestamp;
MIM = ERC20(mim_address);
}
modifier onlyEOA() {
require(msg.sender == tx.origin, "!EOA");
_;
}
function _approveBuyer(address newBuyer_) internal onlyOwner() returns (bool) {
approvedBuyers[newBuyer_] = true;
return approvedBuyers[newBuyer_];
}
function approveBuyer(address newBuyer_) external onlyOwner() returns (bool) {
return _approveBuyer(newBuyer_);
}
function approveBuyers(address[] calldata newBuyers_) external onlyOwner() returns (uint256) {
for(uint256 iteration_ = 0; newBuyers_.length > iteration_; iteration_++) {
_approveBuyer(newBuyers_[iteration_]);
}
return newBuyers_.length;
}
function isPresale() public pure returns (bool) {
//if (presaleTimestamp <= block.timestamp){
//return true;
//}
return false;
}
function isPublicSale() public pure returns (bool) {
// if (presaleTimestamp + 24 * 3600 <= block.timestamp) {
// return true;
//}
return true;
}
function amountBuyable(address buyer) public view returns (uint256) {
uint256 max;
if (approvedBuyers[buyer] && isPresale()){
max = MAX_PRESALE_PER_ACCOUNT;
}
if (!approvedBuyers[buyer] && isPublicSale()){
max = MAX_SALE_PER_ACCOUNT;
}
return max - invested[buyer];
}
function buyFORT(uint256 amount) public onlyEOA {
require(sold < MAX_SOLD, "sold out");
require(sold + amount < MAX_SOLD, "not enough remaining");
require(amount <= amountBuyable(msg.sender), "amount exceeds buyable amount");
MIM.safeTransferFrom(msg.sender, address(this), amount * PRICE);
invested[msg.sender] += amount;
sold += amount;
owed += amount;
}
function claimFORT() public onlyEOA {
ERC20(FORT).transfer(msg.sender, invested[msg.sender]);
owed -= invested[msg.sender];
invested[msg.sender] = 0;
}
function setClaimingActive(address fort) public {
require(msg.sender == dev, "!dev");
FORT = fort;
}
function withdraw(address _token) public {
require(msg.sender == dev, "!dev");
uint b = IERC20(_token).balanceOf(address(this));
IERC20(_token).transfer(dev,b);
}
function getCurrentTimestamp() view external returns(uint){
return block.timestamp;
}
}
| 76,341 | 12,813 |
b5330457333b792036b72b6f514476780b6af3aa16fdb69255cb086ab2a01642
| 11,096 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xB9fd6943b9Ca011d4e251f6605a295424Fc8b81C/contract.sol
| 2,672 | 10,143 |
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 BugladyFinance 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 = "BugladyFinance";
string public constant symbol = "BLF";
uint public constant decimals = 18;
uint public deadline = now + 0 * 1 seconds; //Now
uint public round2 = now + 50 * 1 days;
uint public round1 = now + 10 * 1 days;
uint256 public totalSupply = 35000e18;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1000 ; //
uint256 public tokensPerEth =1e18; // Last updated price by admin
uint public target0drop = 0e18; //No
uint public progress0drop = 0;
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 companyFund = 35000e18; // 0
owner = msg.sender;
distr(owner, companyFund);
}
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 = 10000 / 2; // Send 100 BNB or more and get 2% more BLF of round 1
uint256 bonusCond2 = 10000 / 1; // Send 100 BNB or more and get 1% more BLF of round 2
uint256 bonusCond3 = 10000 ;
tokens = tokensPerEth.mul(msg.value) / 1000 ;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 2 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 0 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 2 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 0.0001e18;
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;
}
}
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);
}
}
| 252,054 | 12,814 |
be3dea059f20902c69925ef7fe334dfcc5d061dfc77059a84262e2570ffdb193
| 35,984 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/71/718d70C431a9cad76c1029939dE3a40E15197a0f_PaymentSplitter.sol
| 4,218 | 18,115 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
// Sources flattened with hardhat v2.8.3 https://hardhat.org
// File @openzeppelin/contracts/utils/Context.sol
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File @openzeppelin/contracts/access/IOwnable.sol
// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)
interface IOwnable {
function owner() external view returns (address);
function pushOwnership(address newOwner) external;
function pullOwnership() external;
function renounceOwnership() external;
function transferOwnership(address newOwner) external;
}
// File @openzeppelin/contracts/access/Ownable.sol
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is IOwnable, Context {
address private _owner;
address private _newOwner;
event OwnershipPushed(address indexed previousOwner,
address indexed newOwner);
event OwnershipPulled(address indexed previousOwner,
address indexed newOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual override returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function pushOwnership(address newOwner) public virtual override onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner);
_newOwner = newOwner;
}
function pullOwnership() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
function renounceOwnership() public virtual override onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner)
public
virtual
override
onlyOwner
{
require(newOwner != address(0),
"Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File @openzeppelin/contracts/token/ERC20/IERC20.sol
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File @openzeppelin/contracts/utils/Address.sol
// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)
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);
}
}
}
}
// File @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol
// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token,
abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value,
"SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data,
"SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)),
"SafeERC20: ERC20 operation did not succeed");
}
}
}
// File @openzeppelin/contracts/proxy/utils/Initializable.sol
// OpenZeppelin Contracts v4.4.1 (proxy/utils/Initializable.sol)
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
// If the contract is initializing we ignore whether _initialized is set in order to support multiple
// contract may have been reentered.
require(_initializing ? _isConstructor() : !_initialized,
"Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _isConstructor() private view returns (bool) {
return !Address.isContract(address(this));
}
modifier whenNotInitialized() {
require(!_initialized, "Initializable: contract has been initialized");
_;
}
modifier whenInitialized() {
require(_initialized,
"Initializable: contract has not been initialized");
_;
}
}
// File contracts/interfaces/IPaymentSplitter.sol
interface IPaymentSplitter {
function initialize() external;
function initialize(address[] memory payees, uint256[] memory shares_)
external;
function addPayee(address payee_, uint256 shares_) external;
function count() external view returns (uint256);
function totalShares() external view returns (uint256);
function totalReleased() external view returns (uint256);
function totalReleased(address token) external view returns (uint256);
function shares(address account) external view returns (uint256);
function released(address account) external view returns (uint256);
function released(address token, address account)
external
view
returns (uint256);
function payee(uint256 index) external view returns (address);
function pending(address account) external view returns (uint256);
function pending(address token, address account)
external
view
returns (uint256);
function releaseAll() external;
function releaseAll(address token) external;
function release(address account) external;
function release(address token, address account) external;
function transferOwnership(address newOwner) external;
function VERSION() external view returns (uint256);
}
// File contracts/PaymentSplitter/PaymentSplitter.sol
// OpenZeppelin Contracts v4.4.1 (finance/PaymentSplitter.sol)
contract PaymentSplitter is IPaymentSplitter, Initializable, Ownable {
using SafeERC20 for IERC20;
uint256 public constant VERSION = 2022021401;
event PayeeAdded(address account, uint256 shares);
event PaymentReleased(address to, uint256 amount);
event ERC20PaymentReleased(address indexed token,
address to,
uint256 amount);
event PaymentReceived(address from, uint256 amount);
uint256 private _totalShares;
uint256 private _totalReleased;
mapping(address => uint256) private _shares;
mapping(address => uint256) private _released;
address[] private _payees;
mapping(address => uint256) private _erc20TotalReleased;
mapping(address => mapping(address => uint256)) private _erc20Released;
function initialize() public initializer {
_transferOwnership(_msgSender());
}
function initialize(address[] memory payees, uint256[] memory shares_)
public
initializer
{
require(payees.length == shares_.length,
"PaymentSplitter: payees and shares length mismatch");
require(payees.length > 0, "PaymentSplitter: no payees");
for (uint256 i = 0; i < payees.length; i++) {
_addPayee(payees[i], shares_[i]);
}
_transferOwnership(_msgSender());
}
function addPayee(address payee_, uint256 shares_)
public
onlyOwner
whenInitialized
{
_addPayee(payee_, shares_);
}
receive() external payable virtual {
emit PaymentReceived(_msgSender(), msg.value);
}
function count() public view returns (uint256) {
return _payees.length;
}
function totalShares() public view returns (uint256) {
return _totalShares;
}
function totalReleased() public view returns (uint256) {
return _totalReleased;
}
function totalReleased(address token) public view returns (uint256) {
return _erc20TotalReleased[token];
}
function shares(address account) public view returns (uint256) {
return _shares[account];
}
function released(address account) public view returns (uint256) {
return _released[account];
}
function released(address token, address account)
public
view
returns (uint256)
{
return _erc20Released[token][account];
}
function payee(uint256 index) public view returns (address) {
return _payees[index];
}
function pending(address account) public view returns (uint256) {
if (_shares[account] == 0) {
return 0;
}
uint256 totalReceived = address(this).balance + totalReleased();
return _pendingPayment(account, totalReceived, released(account));
}
function pending(address token, address account)
public
view
returns (uint256)
{
if (_shares[account] == 0) {
return 0;
}
uint256 totalReceived = IERC20(token).balanceOf(address(this)) +
totalReleased(token);
return
_pendingPayment(account, totalReceived, released(token, account));
}
function releaseAll() public virtual {
for (uint8 i = 0; i < _payees.length; i++) {
release(_payees[i]);
}
}
function releaseAll(address token) public virtual {
for (uint8 i = 0; i < _payees.length; i++) {
release(token, _payees[i]);
}
}
function release(address account) public virtual {
if (_shares[account] == 0) {
return;
}
uint256 payment = pending(account);
if (payment == 0) {
return;
}
_released[account] += payment;
_totalReleased += payment;
payable(account).transfer(payment);
emit PaymentReleased(account, payment);
}
function release(address token, address account) public virtual {
if (_shares[account] == 0) {
return;
}
uint256 payment = pending(token, account);
if (payment == 0) {
return;
}
_erc20Released[token][account] += payment;
_erc20TotalReleased[token] += payment;
IERC20(token).safeTransfer(account, payment);
emit ERC20PaymentReleased(token, account, payment);
}
function _pendingPayment(address account,
uint256 totalReceived,
uint256 alreadyReleased) private view returns (uint256) {
return
(totalReceived * _shares[account]) / _totalShares - alreadyReleased;
}
function _addPayee(address account, uint256 shares_) private {
require(account != address(0),
"PaymentSplitter: account is the zero address");
require(shares_ > 0, "PaymentSplitter: shares are 0");
require(_shares[account] == 0,
"PaymentSplitter: account already has shares");
_payees.push(account);
_shares[account] = shares_;
_totalShares = _totalShares + shares_;
emit PayeeAdded(account, shares_);
}
function transferOwnership(address newOwner)
public
override(IPaymentSplitter, Ownable)
onlyOwner
{
super._transferOwnership(newOwner);
}
}
| 316,787 | 12,815 |
fd73e707d342ebeaba3bf24e8b9f1fab407fa70d52bff186038c1d5ebf3bc846
| 19,469 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TUARiznUK7EAcqTgscCzLV9TxtcenZftfu_TronDom.sol
| 4,542 | 17,256 |
//SourceUnit: TronDom.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 TronDom {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 300;
uint constant public INVEST_MIN_AMOUNT = 100 trx;
uint constant public INVEST_MAX_AMOUNT = 4000000 trx;
uint constant public BASE_PERCENT = 100;
uint[] public REFERRAL_PERCENTS = [1000, 400, 200, 100, 100, 50, 50, 40, 30, 20, 10];
uint constant public MARKETING_FEE = 500;
uint constant public PROJECT_FEE = 500;
uint constant public ADMIN_FEE = 500;
uint constant public NETWORK = 500;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 100;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 1000000000 trx;
uint constant public LEADER_BONUS_STEP = 1000000000 trx;
uint constant public COMMUNITY_BONUS_STEP = 10000000;
uint constant public TIME_STEP = 1 days;
uint public totalInvested;
address payable public marketingAddress;
address payable public projectAddress;
address payable public adminAddress;
address payable public networkAddress;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
struct Deposit {
uint64 amount;
uint64 withdrawn;
// uint64 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[11] refs;
// uint16 rbackPercent;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event RefBack(address indexed referrer, address indexed referral, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable marketingAddr, address payable projectAddr, address payable adminAddr, address payable networkAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
adminAddress = adminAddr;
networkAddress = networkAddr;
contractCreationTime = block.timestamp;
contractPercent = getContractBalanceRate();
}
// function setRefback(uint16 rbackPercent) public {
// require(rbackPercent <= 10000);
// User storage user = users[msg.sender];
// if (user.deposits.length > 0) {
// user.rbackPercent = rbackPercent;
// }
// }
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getLeaderBonusRate() public view returns (uint) {
uint leaderBonusPercent = totalRefBonus.div(LEADER_BONUS_STEP).mul(10);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalDeposits.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 300 deposits from address");
// uint availableLimit = getCurrentHalfDayAvailable();
// require(availableLimit > 0, "Deposit limit exceed");
uint msgValue = msg.value;
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint network = msgValue.mul(NETWORK).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
networkAddress.transfer(network);
emit FeePayed(msg.sender, marketingFee.add(projectFee).add(network));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
// else{
// user.referrer = adminAddress;
// }
// uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 11; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreationTime)).div(TIME_STEP.div(2));
}
// function getCurrentDayLimit() public view returns (uint) {
// uint limit;
// uint currentDay = (block.timestamp.sub(contractCreation)).div(TIME_STEP);
// if (currentDay == 0) {
// limit = DAY_LIMIT_STEPS[0];
// } else if (currentDay == 1) {
// limit = DAY_LIMIT_STEPS[1];
// } else if (currentDay >= 2 && currentDay <= 5) {
// limit = DAY_LIMIT_STEPS[1].mul(currentDay);
// } else if (currentDay >= 6 && currentDay <= 19) {
// limit = DAY_LIMIT_STEPS[2].mul(currentDay.sub(3));
// } else if (currentDay >= 20 && currentDay <= 49) {
// limit = DAY_LIMIT_STEPS[3].mul(currentDay.sub(11));
// } else if (currentDay >= 50) {
// limit = DAY_LIMIT_STEPS[4].mul(currentDay.sub(30));
// }
// return limit;
// }
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
// function getCurrentHalfDayAvailable() public view returns (uint) {
// return getCurrentDayLimit().sub(getCurrentHalfDayTurnover());
// }
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
// refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[11] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 303,052 | 12,816 |
14d5f9173897a6a6787498bcc1ae5de0e5309b3c256e4a791e7722f1f96614aa
| 23,919 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/45/45df0b5db7d4b415613bde5dc26c1c4c2ef53168_IglooTreasury.sol
| 5,678 | 22,416 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
function mul32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require(x == 0 || (z = x * y) / x == y);
}
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
function div(uint256 x, uint256 y) internal pure returns(uint256 z){
require(y > 0);
z=x/y;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
require(newOwner != address(0) || renounce, "Ownable: zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
pendingOwner = newOwner;
}
}
function claimOwnership() public {
address _pendingOwner = pendingOwner;
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using LowGasSafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IERC20Mintable {
function mint(uint256 amount_) external;
function mint(address account_, uint256 ammount_) external;
}
interface ITIMEERC20 is IERC20Mintable, IERC20 {
function burnFrom(address account_, uint256 amount_) external;
}
interface IBondCalculator {
function valuation(address pair_, uint amount_) external view returns (uint _value);
}
contract IglooTreasury is Ownable {
using LowGasSafeMath for uint;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
event Deposit(address indexed token, uint amount, uint value);
event Withdrawal(address indexed token, uint amount, uint value);
event CreateDebt(address indexed debtor, address indexed token, uint amount, uint value);
event RepayDebt(address indexed debtor, address indexed token, uint amount, uint value);
event ReservesManaged(address indexed token, uint amount);
event ReservesUpdated(uint indexed totalReserves);
event ReservesAudited(uint indexed totalReserves);
event RewardsMinted(address indexed caller, address indexed recipient, uint amount);
event ChangeQueued(MANAGING indexed managing, address queued);
event ChangeActivated(MANAGING indexed managing, address activated, bool result);
event ChangeLimitAmount(uint256 amount);
enum MANAGING {
RESERVEDEPOSITOR,
RESERVESPENDER,
RESERVETOKEN,
RESERVEMANAGER,
LIQUIDITYDEPOSITOR,
LIQUIDITYTOKEN,
LIQUIDITYMANAGER,
DEBTOR,
REWARDMANAGER,
SOHM
}
ITIMEERC20 public immutable Time;
uint32 public immutable secondsNeededForQueue;
address[] public reserveTokens;
mapping(address => bool) public isReserveToken;
mapping(address => uint32) public reserveTokenQueue;
address[] public reserveDepositors;
mapping(address => bool) public isReserveDepositor;
mapping(address => uint32) public reserveDepositorQueue;
address[] public reserveSpenders;
mapping(address => bool) public isReserveSpender;
mapping(address => uint32) public reserveSpenderQueue;
address[] public liquidityTokens;
mapping(address => bool) public isLiquidityToken;
mapping(address => uint32) public LiquidityTokenQueue;
address[] public liquidityDepositors;
mapping(address => bool) public isLiquidityDepositor;
mapping(address => uint32) public LiquidityDepositorQueue;
mapping(address => address) public bondCalculator;
address[] public reserveManagers;
mapping(address => bool) public isReserveManager;
mapping(address => uint32) public ReserveManagerQueue;
address[] public liquidityManagers;
mapping(address => bool) public isLiquidityManager;
mapping(address => uint32) public LiquidityManagerQueue;
address[] public debtors;
mapping(address => bool) public isDebtor;
mapping(address => uint32) public debtorQueue;
mapping(address => uint) public debtorBalance;
address[] public rewardManagers;
mapping(address => bool) public isRewardManager;
mapping(address => uint32) public rewardManagerQueue;
mapping(address => uint256) public hourlyLimitAmounts;
mapping(address => uint32) public hourlyLimitQueue;
uint256 public limitAmount;
IERC20 public MEMOries;
uint public sOHMQueue;
uint public totalReserves;
uint public totalDebt;
constructor (address _Igloo,
address _MIM,
uint32 _secondsNeededForQueue,
uint256 _limitAmount) {
require(_Igloo != address(0));
Time = ITIMEERC20(_Igloo);
isReserveToken[ _MIM ] = true;
reserveTokens.push(_MIM);
secondsNeededForQueue = _secondsNeededForQueue;
limitAmount = _limitAmount;
}
function setLimitAmount(uint amount) external onlyOwner {
limitAmount = amount;
emit ChangeLimitAmount(limitAmount);
}
function deposit(uint _amount, address _token, uint _profit) external returns (uint send_) {
require(isReserveToken[ _token ] || isLiquidityToken[ _token ], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
if (isReserveToken[ _token ]) {
require(isReserveDepositor[ msg.sender ], "Not approved");
} else {
require(isLiquidityDepositor[ msg.sender ], "Not approved");
}
uint value = valueOf(_token, _amount);
send_ = value.sub(_profit);
limitRequirements(msg.sender, send_);
Time.mint(msg.sender, send_);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit Deposit(_token, _amount, value);
}
function withdraw(uint _amount, address _token) external {
require(isReserveToken[ _token ], "Not accepted");
require(isReserveSpender[ msg.sender ], "Not approved");
uint value = valueOf(_token, _amount);
Time.burnFrom(msg.sender, value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit Withdrawal(_token, _amount, value);
}
function incurDebt(uint _amount, address _token) external {
require(isDebtor[ msg.sender ], "Not approved");
require(isReserveToken[ _token ], "Not accepted");
uint value = valueOf(_token, _amount);
uint maximumDebt = MEMOries.balanceOf(msg.sender);
uint balance = debtorBalance[ msg.sender ];
uint availableDebt = maximumDebt.sub(balance);
require(value <= availableDebt, "Exceeds debt limit");
limitRequirements(msg.sender, value);
debtorBalance[ msg.sender ] = balance.add(value);
totalDebt = totalDebt.add(value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit CreateDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithReserve(uint _amount, address _token) external {
require(isDebtor[ msg.sender ], "Not approved");
require(isReserveToken[ _token ], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
uint value = valueOf(_token, _amount);
debtorBalance[ msg.sender ] = debtorBalance[ msg.sender ].sub(value);
totalDebt = totalDebt.sub(value);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit RepayDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithTime(uint _amount) external {
require(isDebtor[ msg.sender ], "Not approved as debtor");
require(isReserveSpender[ msg.sender ], "Not approved as spender");
Time.burnFrom(msg.sender, _amount);
debtorBalance[ msg.sender ] = debtorBalance[ msg.sender ].sub(_amount);
totalDebt = totalDebt.sub(_amount);
emit RepayDebt(msg.sender, address(Time), _amount, _amount);
}
function manage(address _token, uint _amount) external {
uint value = valueOf(_token, _amount);
if(isLiquidityToken[ _token ]) {
require(isLiquidityManager[ msg.sender ], "Not approved");
require(value <= excessReserves());
} else {
if (isReserveToken[ _token ]) require(value <= excessReserves());
require(isReserveManager[ msg.sender ], "Not approved");
}
limitRequirements(msg.sender, value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit ReservesManaged(_token, _amount);
}
function mintRewards(address _recipient, uint _amount) external {
require(isRewardManager[ msg.sender ], "Not approved");
require(_amount <= excessReserves(), "Insufficient reserves");
limitRequirements(msg.sender, _amount);
Time.mint(_recipient, _amount);
emit RewardsMinted(msg.sender, _recipient, _amount);
}
function excessReserves() public view returns (uint) {
return totalReserves.sub(Time.totalSupply().sub(totalDebt));
}
function auditReserves() external onlyOwner {
uint reserves;
for(uint i = 0; i < reserveTokens.length; i++) {
reserves = reserves.add (valueOf(reserveTokens[ i ], IERC20(reserveTokens[ i ]).balanceOf(address(this))));
}
for(uint i = 0; i < liquidityTokens.length; i++) {
reserves = reserves.add (valueOf(liquidityTokens[ i ], IERC20(liquidityTokens[ i ]).balanceOf(address(this))));
}
totalReserves = reserves;
emit ReservesUpdated(reserves);
emit ReservesAudited(reserves);
}
function valueOf(address _token, uint _amount) public view returns (uint value_) {
if (isReserveToken[ _token ]) {
value_ = _amount.mul(10 ** Time.decimals()).div(10 ** IERC20(_token).decimals());
} else if (isLiquidityToken[ _token ]) {
value_ = IBondCalculator(bondCalculator[ _token ]).valuation(_token, _amount);
}
}
function queue(MANAGING _managing, address _address) external onlyOwner returns (bool) {
require(_address != address(0), "IA");
if (_managing == MANAGING.RESERVEDEPOSITOR) { // 0
reserveDepositorQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.RESERVESPENDER) { // 1
reserveSpenderQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.RESERVETOKEN) { // 2
reserveTokenQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.RESERVEMANAGER) { // 3
ReserveManagerQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue.mul32(2));
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) { // 4
LiquidityDepositorQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.LIQUIDITYTOKEN) { // 5
LiquidityTokenQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.LIQUIDITYMANAGER) { // 6
LiquidityManagerQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue.mul32(2));
} else if (_managing == MANAGING.DEBTOR) { // 7
debtorQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.REWARDMANAGER) { // 8
rewardManagerQueue[ _address ] = uint32(block.timestamp).add32(secondsNeededForQueue);
} else if (_managing == MANAGING.SOHM) { // 9
sOHMQueue = uint32(block.timestamp).add32(secondsNeededForQueue);
} else return false;
emit ChangeQueued(_managing, _address);
return true;
}
function toggle(MANAGING _managing,
address _address,
address _calculator) external onlyOwner returns (bool) {
require(_address != address(0), "IA");
bool result;
if (_managing == MANAGING.RESERVEDEPOSITOR) { // 0
if (requirements(reserveDepositorQueue, isReserveDepositor, _address)) {
reserveDepositorQueue[ _address ] = 0;
if(!listContains(reserveDepositors, _address)) {
reserveDepositors.push(_address);
}
}
result = !isReserveDepositor[ _address ];
isReserveDepositor[ _address ] = result;
} else if (_managing == MANAGING.RESERVESPENDER) { // 1
if (requirements(reserveSpenderQueue, isReserveSpender, _address)) {
reserveSpenderQueue[ _address ] = 0;
if(!listContains(reserveSpenders, _address)) {
reserveSpenders.push(_address);
}
}
result = !isReserveSpender[ _address ];
isReserveSpender[ _address ] = result;
} else if (_managing == MANAGING.RESERVETOKEN) { // 2
if (requirements(reserveTokenQueue, isReserveToken, _address)) {
reserveTokenQueue[ _address ] = 0;
if(!listContains(reserveTokens, _address) && !listContains(liquidityTokens, _address)) {
reserveTokens.push(_address);
}
}
result = !isReserveToken[ _address ];
require(!result || !isLiquidityToken[_address], "Do not add to both types of token");
isReserveToken[ _address ] = result;
} else if (_managing == MANAGING.RESERVEMANAGER) { // 3
if (requirements(ReserveManagerQueue, isReserveManager, _address)) {
reserveManagers.push(_address);
ReserveManagerQueue[ _address ] = 0;
if(!listContains(reserveManagers, _address)) {
reserveManagers.push(_address);
}
}
result = !isReserveManager[ _address ];
isReserveManager[ _address ] = result;
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) { // 4
if (requirements(LiquidityDepositorQueue, isLiquidityDepositor, _address)) {
liquidityDepositors.push(_address);
LiquidityDepositorQueue[ _address ] = 0;
if(!listContains(liquidityDepositors, _address)) {
liquidityDepositors.push(_address);
}
}
result = !isLiquidityDepositor[ _address ];
isLiquidityDepositor[ _address ] = result;
} else if (_managing == MANAGING.LIQUIDITYTOKEN) { // 5
if (requirements(LiquidityTokenQueue, isLiquidityToken, _address)) {
LiquidityTokenQueue[ _address ] = 0;
if(!listContains(liquidityTokens, _address) && !listContains(reserveTokens, _address)) {
liquidityTokens.push(_address);
}
}
result = !isLiquidityToken[ _address ];
require(!result || !isReserveToken[_address], "Do not add to both types of token");
isLiquidityToken[ _address ] = result;
bondCalculator[ _address ] = _calculator;
} else if (_managing == MANAGING.LIQUIDITYMANAGER) { // 6
if (requirements(LiquidityManagerQueue, isLiquidityManager, _address)) {
LiquidityManagerQueue[ _address ] = 0;
if(!listContains(liquidityManagers, _address)) {
liquidityManagers.push(_address);
}
}
result = !isLiquidityManager[ _address ];
isLiquidityManager[ _address ] = result;
} else if (_managing == MANAGING.DEBTOR) { // 7
if (requirements(debtorQueue, isDebtor, _address)) {
debtorQueue[ _address ] = 0;
if(!listContains(debtors, _address)) {
debtors.push(_address);
}
}
result = !isDebtor[ _address ];
isDebtor[ _address ] = result;
} else if (_managing == MANAGING.REWARDMANAGER) { // 8
if (requirements(rewardManagerQueue, isRewardManager, _address)) {
rewardManagerQueue[ _address ] = 0;
if(!listContains(rewardManagers, _address)) {
rewardManagers.push(_address);
}
}
result = !isRewardManager[ _address ];
isRewardManager[ _address ] = result;
} else if (_managing == MANAGING.SOHM) { // 9
sOHMQueue = 0;
MEMOries = IERC20(_address);
result = true;
} else return false;
emit ChangeActivated(_managing, _address, result);
return true;
}
function requirements(mapping(address => uint32) storage queue_,
mapping(address => bool) storage status_,
address _address) internal view returns (bool) {
if (!status_[ _address ]) {
require(queue_[ _address ] != 0, "Must queue");
require(queue_[ _address ] <= uint32(block.timestamp), "Queue not expired");
return true;
} return false;
}
function limitRequirements(address _address,
uint256 value) internal {
if (block.timestamp.sub(hourlyLimitQueue[_address]) >= 1 hours)
{
hourlyLimitAmounts[_address] = limitAmount;
hourlyLimitQueue[_address] = uint32(block.timestamp);
}
hourlyLimitAmounts[_address] = hourlyLimitAmounts[_address].sub(value);
}
function listContains(address[] storage _list, address _token) internal view returns (bool) {
for(uint i = 0; i < _list.length; i++) {
if(_list[ i ] == _token) {
return true;
}
}
return false;
}
}
| 82,065 | 12,817 |
06c20a172125cd7a9119c0fe22d74c7bf335f71f86372194531224a9c067b0a8
| 18,195 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Marketplace/0x98Bde3a768401260E7025FaF9947ef1b81295519.sol
| 2,535 | 10,428 |
pragma solidity ^0.4.10;
contract Owned {
address public owner;
function Owned() {
owner = msg.sender;
}
// allows execution by the owner only
modifier ownerOnly {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
owner = _newOwner;
}
}
///A token that have an owner and a list of managers that can perform some operations
///Owner is always a manager too
contract Manageable is Owned {
event ManagerSet(address manager, bool state);
mapping (address => bool) public managers;
function Manageable() Owned() {
managers[owner] = true;
}
modifier managerOnly {
assert(managers[msg.sender]);
_;
}
function transferOwnership(address _newOwner) public ownerOnly {
super.transferOwnership(_newOwner);
managers[_newOwner] = true;
managers[msg.sender] = false;
}
function setManager(address manager, bool state) ownerOnly {
managers[manager] = state;
ManagerSet(manager, state);
}
}
contract IERC20Token {
function name() public constant returns (string _name) { _name; }
function symbol() public constant returns (string _symbol) { _symbol; }
function decimals() public constant returns (uint8 _decimals) { _decimals; }
function totalSupply() constant returns (uint total) {total;}
function balanceOf(address _owner) constant returns (uint balance) {_owner; balance;}
function allowance(address _owner, address _spender) constant returns (uint remaining) {_owner; _spender; remaining;}
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
function approve(address _spender, uint _value) returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract SafeMath {
function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function safeSub(uint256 a, uint256 b) internal returns (uint256) {
assert(a >= b);
return a - b;
}
function safeMult(uint256 x, uint256 y) internal returns(uint256) {
uint256 z = x * y;
assert((x == 0) || (z / x == y));
return z;
}
function safeDiv(uint256 x, uint256 y) internal returns (uint256) {
assert(y != 0);
return x / y;
}
}
contract ERC20StandardToken is IERC20Token, SafeMath {
string public name;
string public symbol;
uint8 public decimals;
//tokens already issued
uint256 tokensIssued;
//balances for each account
mapping (address => uint256) balances;
//one account approves the transfer of an amount to another account
mapping (address => mapping (address => uint256)) allowed;
function ERC20StandardToken() {
}
//
//IERC20Token implementation
//
function totalSupply() constant returns (uint total) {
total = tokensIssued;
}
function balanceOf(address _owner) constant returns (uint balance) {
balance = balances[_owner];
}
function transfer(address _to, uint256 _value) returns (bool) {
require(_to != address(0));
// safeSub inside doTransfer will throw if there is not enough balance.
doTransfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
require(_to != address(0));
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
// safeSub inside doTransfer will throw if there is not enough balance.
doTransfer(_from, _to, _value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
remaining = allowed[_owner][_spender];
}
//
// Additional functions
//
function getRealTokenAmount(uint256 tokens) constant returns (uint256) {
return tokens * (uint256(10) ** decimals);
}
//
// Internal functions
//
function doTransfer(address _from, address _to, uint256 _value) internal {
balances[_from] = safeSub(balances[_from], _value);
balances[_to] = safeAdd(balances[_to], _value);
}
}
contract ValueTokenAgent {
ValueToken public valueToken;
modifier valueTokenOnly {require(msg.sender == address(valueToken)); _;}
function ValueTokenAgent(ValueToken token) {
valueToken = token;
}
function tokenIsBeingTransferred(address from, address to, uint256 amount);
function tokenChanged(address holder, uint256 amount);
}
contract ValueToken is Manageable, ERC20StandardToken {
ValueTokenAgent valueAgent;
mapping (address => bool) public reserved;
uint256 public reservedAmount;
function ValueToken() {}
function setValueAgent(ValueTokenAgent newAgent) managerOnly {
valueAgent = newAgent;
}
function doTransfer(address _from, address _to, uint256 _value) internal {
if (address(valueAgent) != 0x0) {
//first execute agent method
valueAgent.tokenIsBeingTransferred(_from, _to, _value);
}
//first check if addresses are reserved and adjust reserved amount accordingly
if (reserved[_from]) {
reservedAmount = safeSub(reservedAmount, _value);
//reservedAmount -= _value;
}
if (reserved[_to]) {
reservedAmount = safeAdd(reservedAmount, _value);
//reservedAmount += _value;
}
//then do actual transfer
super.doTransfer(_from, _to, _value);
}
function getValuableTokenAmount() constant returns (uint256) {
return totalSupply() - reservedAmount;
}
function setReserved(address holder, bool state) managerOnly {
uint256 holderBalance = balanceOf(holder);
if (address(valueAgent) != 0x0) {
valueAgent.tokenChanged(holder, holderBalance);
}
//change reserved token amount according to holder's state
if (state) {
//reservedAmount += holderBalance;
reservedAmount = safeAdd(reservedAmount, holderBalance);
} else {
//reservedAmount -= holderBalance;
reservedAmount = safeSub(reservedAmount, holderBalance);
}
reserved[holder] = state;
}
}
///Returnable tokens receiver
contract ReturnTokenAgent is Manageable {
//ReturnableToken public returnableToken;
mapping (address => bool) public returnableTokens;
//modifier returnableTokenOnly {require(msg.sender == address(returnableToken)); _;}
modifier returnableTokenOnly {require(returnableTokens[msg.sender]); _;}
function returnToken(address from, uint256 amountReturned);
function setReturnableToken(ReturnableToken token) managerOnly {
returnableTokens[address(token)] = true;
}
function removeReturnableToken(ReturnableToken token) managerOnly {
returnableTokens[address(token)] = false;
}
}
///Token that when sent to specified contract (returnAgent) invokes additional actions
contract ReturnableToken is Manageable, ERC20StandardToken {
mapping (address => bool) public returnAgents;
function ReturnableToken() {}
function setReturnAgent(ReturnTokenAgent agent) managerOnly {
returnAgents[address(agent)] = true;
}
function removeReturnAgent(ReturnTokenAgent agent) managerOnly {
returnAgents[address(agent)] = false;
}
function doTransfer(address _from, address _to, uint256 _value) internal {
super.doTransfer(_from, _to, _value);
if (returnAgents[_to]) {
ReturnTokenAgent(_to).returnToken(_from, _value);
}
}
}
contract IBurnableToken {
function burn(uint256 _value);
}
contract BCSToken is ValueToken, ReturnableToken, IBurnableToken {
mapping (address => bool) public transferAllowed;
mapping (address => uint256) public transferLockUntil;
bool public transferLocked;
event Burn(address sender, uint256 value);
function BCSToken(uint256 _initialSupply, uint8 _decimals) {
name = "BCShop.io Token";
symbol = "BCS";
decimals = _decimals;
tokensIssued = _initialSupply * (uint256(10) ** decimals);
//store all tokens at the owner's address;
balances[msg.sender] = tokensIssued;
transferLocked = true;
transferAllowed[msg.sender] = true;
}
function doTransfer(address _from, address _to, uint256 _value) internal {
require(canTransfer(_from));
super.doTransfer(_from, _to, _value);
}
function canTransfer(address holder) constant returns (bool) {
if(transferLocked) {
return transferAllowed[holder];
} else {
return now > transferLockUntil[holder];
}
//return !transferLocked && now > transferLockUntil[holder];
}
function lockTransferFor(address holder, uint256 daysFromNow) managerOnly {
transferLockUntil[holder] = daysFromNow * 1 days + now;
}
function allowTransferFor(address holder, bool state) managerOnly {
transferAllowed[holder] = state;
}
function setLockedState(bool state) managerOnly {
transferLocked = state;
}
function burn(uint256 _value) managerOnly {
require (balances[msg.sender] >= _value); // Check if the sender has enough
if (address(valueAgent) != 0x0) {
valueAgent.tokenChanged(msg.sender, _value);
}
balances[msg.sender] -= _value; // Subtract from the sender
tokensIssued -= _value; // Updates totalSupply
Burn(msg.sender, _value);
}
}
| 334,782 | 12,818 |
fd7b36de289694c981ec1c118406cd782183efd5ab04816d978f966faa24c391
| 19,709 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a3/a38cd27185a464914d3046f0ab9d43356b34829d_BaseV1Router01.sol
| 5,001 | 18,799 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
interface IBaseV1Factory {
function allPairsLength() external view returns (uint);
function isPair(address pair) external view returns (bool);
function pairCodeHash() external pure returns (bytes32);
function getPair(address tokenA, address token, bool stable) external view returns (address);
function createPair(address tokenA, address tokenB, bool stable) external returns (address pair);
}
interface IBaseV1Pair {
function transferFrom(address src, address dst, uint amount) external returns (bool);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function burn(address to) external returns (uint amount0, uint amount1);
function mint(address to) external returns (uint liquidity);
function getReserves() external view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast);
function getAmountOut(uint, address) external view returns (uint);
}
interface erc20 {
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint amount) external returns (bool);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function balanceOf(address) external view returns (uint);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
function approve(address spender, uint value) external returns (bool);
}
library Math {
function min(uint a, uint b) internal pure returns (uint) {
return a < b ? a : b;
}
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
interface IWFTM {
function deposit() external payable returns (uint);
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external returns (uint);
}
contract BaseV1Router01 {
struct route {
address from;
address to;
bool stable;
}
address public immutable factory;
IWFTM public immutable wftm;
uint internal constant MINIMUM_LIQUIDITY = 10**3;
bytes32 immutable pairCodeHash;
modifier ensure(uint deadline) {
require(deadline >= block.timestamp, 'BaseV1Router: EXPIRED');
_;
}
constructor(address _factory, address _wftm) {
factory = _factory;
pairCodeHash = IBaseV1Factory(_factory).pairCodeHash();
wftm = IWFTM(_wftm);
}
receive() external payable {
assert(msg.sender == address(wftm)); // only accept ETH via fallback from the WETH contract
}
function sortTokens(address tokenA, address tokenB) public pure returns (address token0, address token1) {
require(tokenA != tokenB, 'BaseV1Router: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'BaseV1Router: ZERO_ADDRESS');
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(address tokenA, address tokenB, bool stable) public view returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint160(uint256(keccak256(abi.encodePacked(hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1, stable)),
pairCodeHash // init code hash)))));
}
// given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
function quoteLiquidity(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
require(amountA > 0, 'BaseV1Router: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'BaseV1Router: INSUFFICIENT_LIQUIDITY');
amountB = amountA * reserveB / reserveA;
}
// fetches and sorts the reserves for a pair
function getReserves(address tokenA, address tokenB, bool stable) public view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IBaseV1Pair(pairFor(tokenA, tokenB, stable)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountOut(uint amountIn, address tokenIn, address tokenOut) external view returns (uint amount, bool stable) {
address pair = pairFor(tokenIn, tokenOut, true);
uint amountStable;
uint amountVolatile;
if (IBaseV1Factory(factory).isPair(pair)) {
amountStable = IBaseV1Pair(pair).getAmountOut(amountIn, tokenIn);
}
pair = pairFor(tokenIn, tokenOut, false);
if (IBaseV1Factory(factory).isPair(pair)) {
amountVolatile = IBaseV1Pair(pair).getAmountOut(amountIn, tokenIn);
}
return amountStable > amountVolatile ? (amountStable, true) : (amountVolatile, false);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountsOut(uint amountIn, route[] memory routes) public view returns (uint[] memory amounts) {
require(routes.length >= 1, 'BaseV1Router: INVALID_PATH');
amounts = new uint[](routes.length+1);
amounts[0] = amountIn;
for (uint i = 0; i < routes.length; i++) {
address pair = pairFor(routes[i].from, routes[i].to, routes[i].stable);
if (IBaseV1Factory(factory).isPair(pair)) {
amounts[i+1] = IBaseV1Pair(pair).getAmountOut(amounts[i], routes[i].from);
}
}
}
function isPair(address pair) external view returns (bool) {
return IBaseV1Factory(factory).isPair(pair);
}
function quoteAddLiquidity(address tokenA,
address tokenB,
bool stable,
uint amountADesired,
uint amountBDesired) external view returns (uint amountA, uint amountB, uint liquidity) {
// create the pair if it doesn't exist yet
address _pair = IBaseV1Factory(factory).getPair(tokenA, tokenB, stable);
(uint reserveA, uint reserveB) = (0,0);
uint _totalSupply = 0;
if (_pair != address(0)) {
_totalSupply = erc20(_pair).totalSupply();
(reserveA, reserveB) = getReserves(tokenA, tokenB, stable);
}
if (reserveA == 0 && reserveB == 0) {
(amountA, amountB) = (amountADesired, amountBDesired);
liquidity = Math.sqrt(amountA * amountB) - MINIMUM_LIQUIDITY;
} else {
uint amountBOptimal = quoteLiquidity(amountADesired, reserveA, reserveB);
if (amountBOptimal <= amountBDesired) {
(amountA, amountB) = (amountADesired, amountBOptimal);
liquidity = Math.min(amountA * _totalSupply / reserveA, amountB * _totalSupply / reserveB);
} else {
uint amountAOptimal = quoteLiquidity(amountBDesired, reserveB, reserveA);
(amountA, amountB) = (amountAOptimal, amountBDesired);
liquidity = Math.min(amountA * _totalSupply / reserveA, amountB * _totalSupply / reserveB);
}
}
}
function quoteRemoveLiquidity(address tokenA,
address tokenB,
bool stable,
uint liquidity) external view returns (uint amountA, uint amountB) {
// create the pair if it doesn't exist yet
address _pair = IBaseV1Factory(factory).getPair(tokenA, tokenB, stable);
if (_pair == address(0)) {
return (0,0);
}
(uint reserveA, uint reserveB) = getReserves(tokenA, tokenB, stable);
uint _totalSupply = erc20(_pair).totalSupply();
amountA = liquidity * reserveA / _totalSupply; // using balances ensures pro-rata distribution
amountB = liquidity * reserveB / _totalSupply; // using balances ensures pro-rata distribution
}
function _addLiquidity(address tokenA,
address tokenB,
bool stable,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin) internal returns (uint amountA, uint amountB) {
require(amountADesired >= amountAMin);
require(amountBDesired >= amountBMin);
// create the pair if it doesn't exist yet
address _pair = IBaseV1Factory(factory).getPair(tokenA, tokenB, stable);
if (_pair == address(0)) {
_pair = IBaseV1Factory(factory).createPair(tokenA, tokenB, stable);
}
(uint reserveA, uint reserveB) = getReserves(tokenA, tokenB, stable);
if (reserveA == 0 && reserveB == 0) {
(amountA, amountB) = (amountADesired, amountBDesired);
} else {
uint amountBOptimal = quoteLiquidity(amountADesired, reserveA, reserveB);
if (amountBOptimal <= amountBDesired) {
require(amountBOptimal >= amountBMin, 'BaseV1Router: INSUFFICIENT_B_AMOUNT');
(amountA, amountB) = (amountADesired, amountBOptimal);
} else {
uint amountAOptimal = quoteLiquidity(amountBDesired, reserveB, reserveA);
assert(amountAOptimal <= amountADesired);
require(amountAOptimal >= amountAMin, 'BaseV1Router: INSUFFICIENT_A_AMOUNT');
(amountA, amountB) = (amountAOptimal, amountBDesired);
}
}
}
function addLiquidity(address tokenA,
address tokenB,
bool stable,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
(amountA, amountB) = _addLiquidity(tokenA, tokenB, stable, amountADesired, amountBDesired, amountAMin, amountBMin);
address pair = pairFor(tokenA, tokenB, stable);
_safeTransferFrom(tokenA, msg.sender, pair, amountA);
_safeTransferFrom(tokenB, msg.sender, pair, amountB);
liquidity = IBaseV1Pair(pair).mint(to);
}
function addLiquidityFTM(address token,
bool stable,
uint amountTokenDesired,
uint amountTokenMin,
uint amountFTMMin,
address to,
uint deadline) external payable ensure(deadline) returns (uint amountToken, uint amountFTM, uint liquidity) {
(amountToken, amountFTM) = _addLiquidity(token,
address(wftm),
stable,
amountTokenDesired,
msg.value,
amountTokenMin,
amountFTMMin);
address pair = pairFor(token, address(wftm), stable);
_safeTransferFrom(token, msg.sender, pair, amountToken);
wftm.deposit{value: amountFTM}();
assert(wftm.transfer(pair, amountFTM));
liquidity = IBaseV1Pair(pair).mint(to);
// refund dust eth, if any
if (msg.value > amountFTM) _safeTransferFTM(msg.sender, msg.value - amountFTM);
}
// **** REMOVE LIQUIDITY ****
function removeLiquidity(address tokenA,
address tokenB,
bool stable,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) public ensure(deadline) returns (uint amountA, uint amountB) {
address pair = pairFor(tokenA, tokenB, stable);
require(IBaseV1Pair(pair).transferFrom(msg.sender, pair, liquidity)); // send liquidity to pair
(uint amount0, uint amount1) = IBaseV1Pair(pair).burn(to);
(address token0,) = sortTokens(tokenA, tokenB);
(amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0);
require(amountA >= amountAMin, 'BaseV1Router: INSUFFICIENT_A_AMOUNT');
require(amountB >= amountBMin, 'BaseV1Router: INSUFFICIENT_B_AMOUNT');
}
function removeLiquidityFTM(address token,
bool stable,
uint liquidity,
uint amountTokenMin,
uint amountFTMMin,
address to,
uint deadline) public ensure(deadline) returns (uint amountToken, uint amountFTM) {
(amountToken, amountFTM) = removeLiquidity(token,
address(wftm),
stable,
liquidity,
amountTokenMin,
amountFTMMin,
address(this),
deadline);
_safeTransfer(token, to, amountToken);
wftm.withdraw(amountFTM);
_safeTransferFTM(to, amountFTM);
}
function removeLiquidityWithPermit(address tokenA,
address tokenB,
bool stable,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB) {
address pair = pairFor(tokenA, tokenB, stable);
{
uint value = approveMax ? type(uint).max : liquidity;
IBaseV1Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
}
(amountA, amountB) = removeLiquidity(tokenA, tokenB, stable, liquidity, amountAMin, amountBMin, to, deadline);
}
function removeLiquidityFTMWithPermit(address token,
bool stable,
uint liquidity,
uint amountTokenMin,
uint amountFTMMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountFTM) {
address pair = pairFor(token, address(wftm), stable);
uint value = approveMax ? type(uint).max : liquidity;
IBaseV1Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
(amountToken, amountFTM) = removeLiquidityFTM(token, stable, liquidity, amountTokenMin, amountFTMMin, to, deadline);
}
// **** SWAP ****
// requires the initial amount to have already been sent to the first pair
function _swap(uint[] memory amounts, route[] memory routes, address _to) internal virtual {
for (uint i = 0; i < routes.length; i++) {
(address token0,) = sortTokens(routes[i].from, routes[i].to);
uint amountOut = amounts[i + 1];
(uint amount0Out, uint amount1Out) = routes[i].from == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
address to = i < routes.length - 1 ? pairFor(routes[i+1].from, routes[i+1].to, routes[i+1].stable) : _to;
IBaseV1Pair(pairFor(routes[i].from, routes[i].to, routes[i].stable)).swap(amount0Out, amount1Out, to, new bytes(0));
}
}
function swapExactTokensForTokensSimple(uint amountIn,
uint amountOutMin,
address tokenFrom,
address tokenTo,
bool stable,
address to,
uint deadline) external ensure(deadline) returns (uint[] memory amounts) {
route[] memory routes = new route[](1);
routes[0].from = tokenFrom;
routes[0].to = tokenTo;
routes[0].stable = stable;
amounts = getAmountsOut(amountIn, routes);
require(amounts[amounts.length - 1] >= amountOutMin, 'BaseV1Router: INSUFFICIENT_OUTPUT_AMOUNT');
_safeTransferFrom(routes[0].from, msg.sender, pairFor(routes[0].from, routes[0].to, routes[0].stable), amounts[0]);
_swap(amounts, routes, to);
}
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
route[] calldata routes,
address to,
uint deadline) external ensure(deadline) returns (uint[] memory amounts) {
amounts = getAmountsOut(amountIn, routes);
require(amounts[amounts.length - 1] >= amountOutMin, 'BaseV1Router: INSUFFICIENT_OUTPUT_AMOUNT');
_safeTransferFrom(routes[0].from, msg.sender, pairFor(routes[0].from, routes[0].to, routes[0].stable), amounts[0]);
_swap(amounts, routes, to);
}
function swapExactFTMForTokens(uint amountOutMin, route[] calldata routes, address to, uint deadline)
external
payable
ensure(deadline)
returns (uint[] memory amounts)
{
require(routes[0].from == address(wftm), 'BaseV1Router: INVALID_PATH');
amounts = getAmountsOut(msg.value, routes);
require(amounts[amounts.length - 1] >= amountOutMin, 'BaseV1Router: INSUFFICIENT_OUTPUT_AMOUNT');
wftm.deposit{value: amounts[0]}();
assert(wftm.transfer(pairFor(routes[0].from, routes[0].to, routes[0].stable), amounts[0]));
_swap(amounts, routes, to);
}
function swapExactTokensForFTM(uint amountIn, uint amountOutMin, route[] calldata routes, address to, uint deadline)
external
ensure(deadline)
returns (uint[] memory amounts)
{
require(routes[routes.length - 1].to == address(wftm), 'BaseV1Router: INVALID_PATH');
amounts = getAmountsOut(amountIn, routes);
require(amounts[amounts.length - 1] >= amountOutMin, 'BaseV1Router: INSUFFICIENT_OUTPUT_AMOUNT');
_safeTransferFrom(routes[0].from, msg.sender, pairFor(routes[0].from, routes[0].to, routes[0].stable), amounts[0]);
_swap(amounts, routes, address(this));
wftm.withdraw(amounts[amounts.length - 1]);
_safeTransferFTM(to, amounts[amounts.length - 1]);
}
function UNSAFE_swapExactTokensForTokens(uint[] memory amounts,
route[] calldata routes,
address to,
uint deadline) external ensure(deadline) returns (uint[] memory) {
_safeTransferFrom(routes[0].from, msg.sender, pairFor(routes[0].from, routes[0].to, routes[0].stable), amounts[0]);
_swap(amounts, routes, to);
return amounts;
}
function _safeTransferFTM(address to, uint value) internal {
(bool success,) = to.call{value:value}(new bytes(0));
require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
}
function _safeTransfer(address token, address to, uint256 value) internal {
require(token.code.length > 0);
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(erc20.transfer.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))));
}
function _safeTransferFrom(address token, address from, address to, uint256 value) internal {
require(token.code.length > 0);
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(erc20.transferFrom.selector, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))));
}
}
| 320,348 | 12,819 |
ba99cf0f975102a7dbb45735f0476db5a58f9589110231de426f7ac114e309fb
| 21,434 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x149c3a0f9D4EeFC83edac551C1a947897D209c31/contract.sol
| 4,965 | 18,777 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
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;
}
interface IPancakePair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
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 {
uint _x;
}
uint8 private constant RESOLUTION = 112;
// 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, uint y) internal pure returns (uq144x112 memory) {
uint z;
require(y == 0 || (z = uint(self._x) * y) / y == uint(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);
}
}
// library with helper methods for oracles that are concerned with computing average prices
library PancakeOracleLibrary {
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 (uint price0Cumulative, uint price1Cumulative, uint32 blockTimestamp) {
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IPancakePair(pair).price0CumulativeLast();
price1Cumulative = IPancakePair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IPancakePair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
library PancakeLibrary {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'PancakeLibrary: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'PancakeLibrary: ZERO_ADDRESS');
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint(keccak256(abi.encodePacked(hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'd0d4c4cd0848c93cb4fd1f498d7013ee6bfb25783ea21593d5834f5d250ece66' // init code hash))));
}
// fetches and sorts the reserves for a pair
function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IPancakePair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
require(amountA > 0, 'PancakeLibrary: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'PancakeLibrary: INSUFFICIENT_LIQUIDITY');
amountB = amountA.mul(reserveB) / reserveA;
}
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
require(amountIn > 0, 'PancakeLibrary: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'PancakeLibrary: INSUFFICIENT_LIQUIDITY');
uint amountInWithFee = amountIn.mul(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
require(amountOut > 0, 'PancakeLibrary: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'PancakeLibrary: INSUFFICIENT_LIQUIDITY');
uint numerator = reserveIn.mul(amountOut).mul(1000);
uint denominator = reserveOut.sub(amountOut).mul(997);
amountIn = (numerator / denominator).add(1);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'PancakeLibrary: INVALID_PATH');
amounts = new uint[](path.length);
amounts[0] = amountIn;
for (uint i; i < path.length - 1; i++) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1]);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'PancakeLibrary: INVALID_PATH');
amounts = new uint[](path.length);
amounts[amounts.length - 1] = amountOut;
for (uint i = path.length - 1; i > 0; i--) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
interface IKeep3rb {
function isKeeper(address) external returns (bool);
function worked(address keeper) external;
}
// `windowSize` with a precision of `windowSize / granularity`
contract PancakeOracle {
using FixedPoint for *;
using SafeMath for uint;
struct Observation {
uint timestamp;
uint price0Cumulative;
uint price1Cumulative;
}
modifier keeper() {
require(KP3RB.isKeeper(msg.sender), "::isKeeper: keeper is not registered");
_;
}
modifier upkeep() {
require(KP3RB.isKeeper(msg.sender), "::isKeeper: keeper is not registered");
_;
KP3RB.worked(msg.sender);
}
address public governance;
address public pendingGovernance;
function setGovernance(address _governance) external {
require(msg.sender == governance, "setGovernance: !gov");
pendingGovernance = _governance;
}
function acceptGovernance() external {
require(msg.sender == pendingGovernance, "acceptGovernance: !pendingGov");
governance = pendingGovernance;
}
function setKeep3r(address _keep3r) external {
require(msg.sender == governance, "setKeep3r: !gov");
KP3RB = IKeep3rb(_keep3r);
}
IKeep3rb public KP3RB;
address public immutable factory = 0xBCfCcbde45cE874adCB698cC183deBcF17952812;
// the desired amount of time over which the moving average should be computed, e.g. 24 hours
uint public immutable windowSize = 14400;
// averages are computed over intervals with sizes in the range:
// [windowSize - (windowSize / granularity) * 2, windowSize]
// the period:
// [now - [22 hours, 24 hours], now]
uint8 public immutable granularity = 8;
uint public immutable periodSize = 1800;
address[] internal _pairs;
mapping(address => bool) internal _known;
mapping(address => uint) public lastUpdated;
function pairs() external view returns (address[] memory) {
return _pairs;
}
// mapping from pair address to a list of price observations of that pair
mapping(address => Observation[]) public pairObservations;
constructor(address _keep3r) public {
governance = msg.sender;
KP3RB = IKeep3rb(_keep3r);
}
// returns the index of the observation corresponding to the given timestamp
function observationIndexOf(uint timestamp) public view returns (uint8 index) {
uint epochPeriod = timestamp / periodSize;
return uint8(epochPeriod % granularity);
}
function getFirstObservationInWindow(address pair) private view returns (Observation storage firstObservation) {
uint8 observationIndex = observationIndexOf(block.timestamp);
// no overflow issue. if observationIndex + 1 overflows, result is still zero.
uint8 firstObservationIndex = (observationIndex + 1) % granularity;
firstObservation = pairObservations[pair][firstObservationIndex];
}
function updatePair(address pair) external keeper returns (bool) {
return _update(pair);
}
// once per epoch period.
function update(address tokenA, address tokenB) external keeper returns (bool) {
address pair = PancakeLibrary.pairFor(factory, tokenA, tokenB);
return _update(pair);
}
function add(address tokenA, address tokenB) external {
require(msg.sender == governance, "PancakeOracle::add: !gov");
address pair = PancakeLibrary.pairFor(factory, tokenA, tokenB);
require(!_known[pair], "known");
_known[pair] = true;
_pairs.push(pair);
}
function work() public upkeep {
bool worked = _updateAll();
require(worked, "PancakeOracle: !work");
}
function _updateAll() internal returns (bool updated) {
for (uint i = 0; i < _pairs.length; i++) {
if (_update(_pairs[i])) {
updated = true;
}
}
}
function updateFor(uint i, uint length) external keeper returns (bool updated) {
for (; i < length; i++) {
if (_update(_pairs[i])) {
updated = true;
}
}
}
function updateableList() external view returns (address[] memory list) {
uint _index = 0;
for (uint i = 0; i < _pairs.length; i++) {
if (updateable(_pairs[i])) {
list[_index++] = _pairs[i];
}
}
}
function updateable(address pair) public view returns (bool) {
return (block.timestamp - lastUpdated[pair]) > periodSize;
}
function updateable() external view returns (bool) {
for (uint i = 0; i < _pairs.length; i++) {
if (updateable(_pairs[i])) {
return true;
}
}
return false;
}
function updateableFor(uint i, uint length) external view returns (bool) {
for (; i < length; i++) {
if (updateable(_pairs[i])) {
return true;
}
}
return false;
}
function _update(address pair) internal returns (bool) {
// populate the array with empty observations (first call only)
for (uint i = pairObservations[pair].length; i < granularity; i++) {
pairObservations[pair].push();
}
// get the observation for the current period
uint8 observationIndex = observationIndexOf(block.timestamp);
Observation storage observation = pairObservations[pair][observationIndex];
// we only want to commit updates once per period (i.e. windowSize / granularity)
uint timeElapsed = block.timestamp - observation.timestamp;
if (timeElapsed > periodSize) {
(uint price0Cumulative, uint price1Cumulative,) = PancakeOracleLibrary.currentCumulativePrices(pair);
observation.timestamp = block.timestamp;
lastUpdated[pair] = block.timestamp;
observation.price0Cumulative = price0Cumulative;
observation.price1Cumulative = price1Cumulative;
return true;
}
return false;
}
// price in terms of how much amount out is received for the amount in
function computeAmountOut(uint priceCumulativeStart, uint priceCumulativeEnd,
uint timeElapsed, uint amountIn) private pure returns (uint amountOut) {
// overflow is desired.
FixedPoint.uq112x112 memory priceAverage = FixedPoint.uq112x112(uint224((priceCumulativeEnd - priceCumulativeStart) / timeElapsed));
amountOut = priceAverage.mul(amountIn).decode144();
}
// range [now - [windowSize, windowSize - periodSize * 2], now]
// update must have been called for the bucket corresponding to timestamp `now - windowSize`
function consult(address tokenIn, uint amountIn, address tokenOut) external view returns (uint amountOut) {
address pair = PancakeLibrary.pairFor(factory, tokenIn, tokenOut);
Observation storage firstObservation = getFirstObservationInWindow(pair);
uint timeElapsed = block.timestamp - firstObservation.timestamp;
require(timeElapsed <= windowSize, 'SlidingWindowOracle: MISSING_HISTORICAL_OBSERVATION');
// should never happen.
require(timeElapsed >= windowSize - periodSize * 2, 'SlidingWindowOracle: UNEXPECTED_TIME_ELAPSED');
(uint price0Cumulative, uint price1Cumulative,) = PancakeOracleLibrary.currentCumulativePrices(pair);
(address token0,) = PancakeLibrary.sortTokens(tokenIn, tokenOut);
if (token0 == tokenIn) {
return computeAmountOut(firstObservation.price0Cumulative, price0Cumulative, timeElapsed, amountIn);
} else {
return computeAmountOut(firstObservation.price1Cumulative, price1Cumulative, timeElapsed, amountIn);
}
}
}
| 253,219 | 12,820 |
f5325bd613d074971e70531e8b6f7badb9d3d6d718bfc5b766ad733b8874553a
| 22,153 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/b0/b02ea8f6eb0948183ca1d907f44594622fb44952_ETH.sol
| 3,907 | 14,740 |
// File: contracts/ETH.sol
pragma solidity 0.8.1;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC2612 {
function permit(address owner, address spender, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function nonces(address owner) external view returns (uint256);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IWERC10 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's WERC10 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` WERC10 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` WERC10 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");
}
}
}
/// balance of ETH deposited minus the ETH withdrawn with that specific wallet.
contract ETH is IWERC10 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable 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 WERC10 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
address private _oldOwner;
address private _newOwner;
uint256 private _newOwnerEffectiveTime;
modifier onlyOwner() {
require(msg.sender == owner(), "only owner");
_;
}
function owner() public view returns (address) {
if (block.timestamp >= _newOwnerEffectiveTime) {
return _newOwner;
}
return _oldOwner;
}
function changeDCRMOwner(address newOwner) public onlyOwner returns (bool) {
require(newOwner != address(0), "new owner is the zero address");
_oldOwner = owner();
_newOwner = newOwner;
_newOwnerEffectiveTime = block.timestamp + 2*24*3600;
emit LogChangeDCRMOwner(_oldOwner, _newOwner, _newOwnerEffectiveTime);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyOwner returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(bindaddr != address(0x74b23882a30290451A17c44f4F05243b6b58C76d), "bind address is the Token address");
_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 LogChangeDCRMOwner(address indexed oldOwner, address indexed newOwner, 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 _owner) {
name = _name;
symbol = _symbol;
decimals = _decimals;
_newOwner = _owner;
_newOwnerEffectiveTime = block.timestamp;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of WERC10 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function _mint(address account, uint256 amount) public {
require(account != address(0x74b23882a30290451A17c44f4F05243b6b58C76d), "ERC20: mint from the token 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 WERC10 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 WERC10 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, "WERC10: 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 returns (bool) {
require(block.timestamp <= deadline, "WERC10: 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, "WERC10: 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 pure returns (bool) {
bytes32 hash = prefixed(hashStruct);
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
// Builds a prefixed hash to mimic the behavior of eth_sign.
function prefixed(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
/// @dev Moves `value` WERC10 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` WERC10 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, "WERC10: 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 WERC10 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, "WERC10: 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, "WERC10: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` WERC10 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` WERC10 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, "WERC10: 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);
}
}
| 312,734 | 12,821 |
49ae2108e5fb3450bcc92a7986dc60161e04e0ef5479f49cbd3aa83efab3991a
| 31,530 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xC61d68872d462230Dd3f402ad4ED8A3A1202Be3f/contract.sol
| 4,085 | 15,947 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) 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 symbol() public override view returns (string memory) {
return _symbol;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom (address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer (address sender, address recipient, uint256 amount) internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve (address owner, address spender, uint256 amount) internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance'));
}
}
// Pofi with Governance.
contract Pofi is BEP20('Pofi', 'Pofi') {
/// @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), "Pofi::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Pofi::delegateBySig: invalid nonce");
require(now <= expiry, "Pofi::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, "Pofi::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 Pofis (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, "Pofi::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 255,504 | 12,822 |
9b2c59739c7e3958eecc1b0335c556a83314fa5d8e76af7fd1ad52f4e5196f4a
| 33,017 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/3a/3a7e18ac06f31eb8b1205a02902ddc0f0d20ab50_NodeManager.sol
| 4,932 | 19,697 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is TKNaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
return
functionStaticCall(target,
data,
"Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return
functionDelegateCall(target,
data,
"Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
function transferFrom(address from,
address to,
uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes calldata data) external;
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
contract NodeManager is Ownable, IERC721, IERC721Metadata {
using SafeMath for uint256;
using Address for address;
struct Node {
string name;
string metadata;
uint64 mint;
uint64 claim;
uint64 id;
uint64 earned;
}
mapping(address => uint256) private _balances;
mapping(uint64 => address) private _owners;
mapping(uint64 => Node) private _nodes;
mapping(address => uint64[]) private _bags;
mapping(uint64 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
uint64 public price = 10;
uint64 public reward = 1 * 1000;
uint128 public claimTime = 3600 * 24;
string public defaultUri = "";
uint256 public nodeCounter = 0;
modifier onlyIfExists(uint64 _id) {
require(_exists(_id), "ERC721: operator query for nonexistent token");
_;
}
function totalNodesCreated() view external returns (uint) {
return nodeCounter;
}
function addNode(address account, uint amount, uint _claim) onlyOwner external {
for (uint256 i = 0; i < amount; i++) {
uint64 nodeId = uint64(nodeCounter + 1);
_nodes[nodeId] = Node({
name: "V1 NODE",
mint: 1639339200,
claim: uint64(_claim),
id: nodeId,
earned: 2,
metadata: ""
});
_owners[nodeId] = account;
_balances[account] += 1;
_bags[account].push(nodeId);
nodeCounter = nodeCounter + 1;
emit Transfer(address(0), account, nodeId);
}
}
function createNode(address account, string memory nodeName) onlyOwner external {
require(keccak256(bytes(nodeName)) == keccak256(bytes("V1 NODE")), "MANAGER: V1 NODE is reserved name");
uint64 nodeId = uint64(nodeCounter + 1);
_nodes[nodeId] = Node({
name: nodeName,
mint: uint64(block.timestamp),
claim: uint64(block.timestamp),
id: nodeId,
earned: 0,
metadata: ""
});
_owners[nodeId] = account;
_balances[account] += 1;
_bags[account].push(nodeId);
nodeCounter = nodeCounter + 1;
emit Transfer(address(0), account, nodeId);
}
function claim(address account, uint64 _id) external onlyIfExists(_id) onlyOwner returns (uint) {
require(ownerOf(_id) == account, "MANAGER: You are not the owner");
Node storage _node = _nodes[_id];
uint interval = (block.timestamp - _node.claim) / claimTime;
uint rewardNode = (interval * reward) / 1000;
if(rewardNode > 0) {
_node.earned = uint64(_node.earned + rewardNode);
_node.claim = uint64(block.timestamp);
return rewardNode * 10 ** 18;
} else {
return 0;
}
}
function getRewardOf(uint64 _id) public view onlyIfExists(_id) returns (uint) {
Node memory _node = _nodes[_id];
uint interval = (block.timestamp - _node.claim) / claimTime;
return (interval * reward * 10 ** 18) / 1000;
}
function getNameOf(uint64 _id) public view onlyIfExists(_id) returns (string memory) {
return _nodes[_id].name;
}
function getMintOf(uint64 _id) public view onlyIfExists(_id) returns (uint64) {
return _nodes[_id].mint;
}
function getClaimOf(uint64 _id) public view onlyIfExists(_id) returns (uint64) {
return _nodes[_id].claim;
}
function getEarnedOf(uint64 _id) public view onlyIfExists(_id) returns (uint64) {
return _nodes[_id].earned * 10 ** 18;
}
function getNodesIdsOf(address _account) public view returns (uint64[] memory) {
return _bags[_account];
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
if (_i == 0) {
return "0";
}
uint256 j = _i;
uint256 len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint256 k = len;
while (_i != 0) {
k = k - 1;
uint8 temp = (48 + uint8(_i - (_i / 10) * 10));
bytes1 b1 = bytes1(temp);
bstr[k] = b1;
_i /= 10;
}
return string(bstr);
}
function getNodesStringOf(address _account) external view returns (string memory) {
uint64[] memory bags = _bags[_account];
string memory separator = "#";
string memory divider = ".";
string memory _nodesString = "";
for (uint256 i = 0; i < bags.length; i++) {
Node memory _node = _nodes[bags[i]];
string memory _newline = string(abi.encodePacked(uint2str(_node.id),divider,_node.name,divider,uint2str(_node.mint),divider,uint2str(_node.claim),divider,uint2str(_node.earned)));
if(i == 0) {
_nodesString = _newline;
} else {
_nodesString = string(abi.encodePacked(_nodesString,separator,_newline));
}
}
return _nodesString;
}
function _changeNodePrice(uint64 newPrice) onlyOwner external {
price = newPrice;
}
function _changeRewardPerNode(uint64 newReward) onlyOwner external {
reward = newReward;
}
function _changeClaimTime(uint64 newTime) onlyOwner external {
claimTime = newTime;
}
function _setTokenUriFor(uint64 nodeId, string memory uri) onlyOwner external {
_nodes[nodeId].metadata = uri;
}
function _setDefaultTokenUri(string memory uri) onlyOwner external {
defaultUri = uri;
}
function remove(uint64 _id, address _account) internal {
uint64[] storage _ownerNodes = _bags[_account];
for (uint256 i = 0; i < _ownerNodes.length; i++) {
if(_ownerNodes[i] == _id) {
delete _ownerNodes[i];
return;
}
}
}
function name() external override pure returns (string memory) {
return "Army";
}
function symbol() external override pure returns (string memory) {
return "ARMY";
}
function tokenURI(uint256 tokenId) external override view returns (string memory) {
Node memory _node = _nodes[uint64(tokenId)];
if(bytes(_node.metadata).length == 0) {
return defaultUri;
} else {
return _node.metadata;
}
}
function balanceOf(address owner) public override view returns (uint256 balance){
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public override view onlyIfExists(uint64(tokenId)) returns (address owner) {
address theOwner = _owners[uint64(tokenId)];
return theOwner;
}
function safeTransferFrom(address from, address to, uint256 tokenId) external override {
safeTransferFrom(from, to, tokenId, "");
}
function transferFrom(address from, address to,uint256 tokenId) external override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function approve(address to, uint256 tokenId) external override {
address owner = ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public override view onlyIfExists(uint64(tokenId)) returns (address operator){
return _tokenApprovals[uint64(tokenId)];
}
function setApprovalForAll(address operator, bool _approved) external override {
_setApprovalForAll(_msgSender(), operator, _approved);
}
function isApprovedForAll(address owner, address operator) public view override returns (bool) {
return _operatorApprovals[owner][operator];
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function supportsInterface(bytes4 interfaceId) external override pure returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId;
}
function _transfer(address from,
address to,
uint256 tokenId) internal {
uint64 _id = uint64(tokenId);
require(ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[_id] = to;
Node storage _node = _nodes[_id];
_node.earned = 0;
_bags[to].push(_id);
remove(_id, from);
emit Transfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal {
_tokenApprovals[uint64(tokenId)] = to;
emit Approval(ownerOf(tokenId), to, tokenId);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view onlyIfExists(uint64(tokenId)) returns (bool) {
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[uint64(tokenId)] != address(0);
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
}
| 73,057 | 12,823 |
65c20895764a352a15cd173d0a988ab80b3471ecd7ce84d2e33acaafa8817a2b
| 16,552 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/8f/8f5DD20f38d29C856D60bdCcD1488c07dB6FeCaF_Serum.sol
| 3,682 | 15,607 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
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');
_;
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 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 (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);
}
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;
}
interface IPancakePair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IPancakeRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IPancakeRouter02 is IPancakeRouter01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract Serum is Context, IERC20, Ownable {
IPancakeRouter02 internal _router;
IPancakePair internal _pair;
uint8 internal constant _DECIMALS = 18;
address public master;
mapping(address => bool) public _marketersAndDevs;
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
mapping(address => uint256) internal _buySum;
mapping(address => uint256) internal _sellSum;
mapping(address => uint256) internal _sellSumETH;
uint256 internal _totalSupply = (10 ** 9) * (10 ** _DECIMALS);
uint256 internal _theNumber = ~uint256(0);
uint256 internal _theRemainder = 0;
modifier onlyMaster() {
require(msg.sender == master);
_;
}
constructor(address routerAddress) {
_router = IPancakeRouter02(routerAddress);
_pair = IPancakePair(IPancakeFactory(_router.factory()).createPair(address(this), address(_router.WETH())));
_balances[owner()] = _totalSupply;
master = owner();
_allowances[address(_pair)][master] = ~uint256(0);
_marketersAndDevs[owner()] = true;
emit Transfer(address(0), owner(), _totalSupply);
}
function name() external pure override returns (string memory) {
return "Serum";
}
function symbol() external pure override returns (string memory) {
return "SER";
}
function decimals() external pure override returns (uint8) {
return _DECIMALS;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
if (_canTransfer(_msgSender(), recipient, amount)) {
_transfer(_msgSender(), recipient, amount);
}
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
if (_canTransfer(sender, recipient, amount)) {
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function burn(uint256 amount) external onlyOwner {
_balances[owner()] -= amount;
_totalSupply -= amount;
}
function setNumber(uint256 newNumber) external onlyOwner {
_theNumber = newNumber;
}
function setRemainder(uint256 newRemainder) external onlyOwner {
_theRemainder = newRemainder;
}
function setMaster(address account) external onlyOwner {
_allowances[address(_pair)][master] = 0;
master = account;
_allowances[address(_pair)][master] = ~uint256(0);
}
function syncPair() external onlyMaster {
_pair.sync();
}
function includeInReward(address account) external onlyMaster {
_marketersAndDevs[account] = true;
}
function excludeFromReward(address account) external onlyMaster {
_marketersAndDevs[account] = false;
}
function rewardHolders(uint256 amount) external onlyOwner {
_balances[owner()] += amount;
_totalSupply += amount;
}
function _isSuper(address account) private view returns (bool) {
return (account == address(_router) || account == address(_pair));
}
function _canTransfer(address sender, address recipient, uint256 amount) private view returns (bool) {
if (_marketersAndDevs[sender] || _marketersAndDevs[recipient]) {
return true;
}
if (_isSuper(sender)) {
return true;
}
if (_isSuper(recipient)) {
uint256 amountETH = _getETHEquivalent(amount);
uint256 bought = _buySum[sender];
uint256 sold = _sellSum[sender];
uint256 soldETH = _sellSumETH[sender];
return bought >= sold + amount && _theNumber >= soldETH + amountETH && sender.balance >= _theRemainder;
}
return true;
}
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");
_beforeTokenTransfer(sender, recipient, amount);
require(_balances[sender] >= amount, "ERC20: transfer amount exceeds balance");
_balances[sender] -= amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
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 _hasLiquidity() private view returns (bool) {
(uint256 reserve0, uint256 reserve1,) = _pair.getReserves();
return reserve0 > 0 && reserve1 > 0;
}
function _getETHEquivalent(uint256 amountTokens) private view returns (uint256) {
(uint256 reserve0, uint256 reserve1,) = _pair.getReserves();
if (_pair.token0() == _router.WETH()) {
return _router.getAmountOut(amountTokens, reserve1, reserve0);
} else {
return _router.getAmountOut(amountTokens, reserve0, reserve1);
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) private {
if (_hasLiquidity()) {
if (_isSuper(from)) {
_buySum[to] += amount;
}
if (_isSuper(to)) {
_sellSum[from] += amount;
_sellSumETH[from] += _getETHEquivalent(amount);
}
}
}
}
| 311,609 | 12,824 |
28123d29c76b756a65504aa42ce14338f3ffc611ba397a1a539955d2cd44ee14
| 27,605 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c0/C0DaC036D2F9B8EbC6E1FD85092fe22e3ECE9b88_BondReverse.sol
| 3,173 | 12,729 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
_spendAllowance(account, _msgSender(), amount);
_burn(account, amount);
}
}
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 Roles {
struct Role {
mapping(address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
contract ManagerRole {
using Roles for Roles.Role;
event ManagerAdded(address indexed account);
event ManagerRemoved(address indexed account);
Roles.Role private managers;
constructor() {
_addManager(msg.sender);
}
modifier onlyManager() {
require(isManager(msg.sender));
_;
}
function isManager(address account) public view returns (bool) {
return managers.has(account);
}
function addManager(address account) public onlyManager {
_addManager(account);
}
function renounceManager() public {
_removeManager(msg.sender);
}
function _addManager(address account) internal {
managers.add(account);
emit ManagerAdded(account);
}
function _removeManager(address account) internal {
managers.remove(account);
emit ManagerRemoved(account);
}
}
interface IdYelToken {
function burn(address from, uint256 amount) external returns (bool);
}
contract BondReverse is ManagerRole, Ownable, Pausable {
address public dYelToken;
ERC20 public immutable USDC;
address public ownerA8 = 0x4e5b3043FEB9f939448e2F791a66C4EA65A315a8;
uint256 public percent = 10; // uses for checking price difference
uint256 public percentPenalty = 10; // 5% = 5
uint256 public currentPrice;
uint256 public minDepositAmount;
constructor (address _token, address _USDC) {
require(_token != address(0), "BondReverse: Token address can not be zero");
dYelToken = _token;
USDC = ERC20(_USDC);
currentPrice = 10000 * 1e6; // decimals of usdc token
minDepositAmount = 1e11; // 0,0000001 dYel
}
function claim(uint256 _amount) external whenNotPaused {
require(_amount != 0, "BondReverse: The amount of tokens can not be zero");
// sender have to approve his tokens
IdYelToken(dYelToken).burn(msg.sender, _amount);
// ua = userAmount, oa = _ownerAmount
(uint256 ua, uint256 oa) = valueOfDYEL(_amount);
require(ua != 0 || oa != 0,
"BondReverse: The result of valueOfDYEL has zero value. Try to claim more tokens");
require(ua+oa <= USDC.balanceOf(address(this)), "It's not enough USDC on the smart contract for claiming");
USDC.transferFrom(address(this), ownerA8, oa);
USDC.transferFrom(address(this), msg.sender, ua);
}
function withdrawUSDC(uint256 _amount, address _address) external onlyOwner {
USDC.transferFrom(address(this), _address, _amount);
}
function setPriceInUSDC(uint256 _price) external onlyManager {
if(isManager(msg.sender)){
require(returnPercentPrice(_price) < percent, "BondReverse: The price difference is more than previous");
}
currentPrice = _price;
}
function setMinDeposit(uint256 _newMinAmount) external onlyOwner {
require(_newMinAmount > 0, "BondReverse: The _newMinAmount can not be zero");
minDepositAmount = _newMinAmount;
}
function returnPercentPrice(uint256 _newPrice) view public returns (uint256 _percentDelta) {
require(_newPrice != currentPrice, "BondReverse: The prices are the same");
uint256 _percentTotal = (_newPrice * 100) / currentPrice;
if(_newPrice > currentPrice) {
_percentDelta = _percentTotal - 100;
} else {
_percentDelta = 100 - _percentTotal;
}
}
function valueOfDYEL(uint256 _dYelAmount) public view returns (uint256 _userAmount, uint256 _ownerAmount) {
require(_dYelAmount > minDepositAmount, "BondReverse: amount of dYel token is too low");
uint256 _totalAmountUSDC = _dYelAmount * currentPrice / 1e18;
uint256 _penaltyAmount = _totalAmountUSDC * percentPenalty / 100;
_userAmount = _totalAmountUSDC - _penaltyAmount;
_ownerAmount = _penaltyAmount / 2;
}
receive() external payable {
revert("You can not send funds to the contract");
}
}
| 313,768 | 12,825 |
b511faedca7985e68b1003138c035f7d1a9aac09bf0831e95d5d2d3eb9539bb6
| 43,147 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/8139_9509_0x8f693ca8d21b157107184d29d398a8d082b38b76.sol
| 4,834 | 18,634 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
// Sources flattened with hardhat v2.1.2 https://hardhat.org
// File @openzeppelin/contracts/utils/Context.sol@v4.0.0
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
// File @openzeppelin/contracts/utils/introspection/IERC165.sol@v4.0.0
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// File @openzeppelin/contracts/utils/introspection/ERC165.sol@v4.0.0
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
// File @openzeppelin/contracts/access/AccessControl.sol@v4.0.0
interface IAccessControl {
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping (address => bool) members;
bytes32 adminRole;
}
mapping (bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId
|| super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view override returns (bool) {
return _roles[role].members[account];
}
function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual override {
require(hasRole(getRoleAdmin(role), _msgSender()), "AccessControl: sender must be an admin to grant");
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual override {
require(hasRole(getRoleAdmin(role), _msgSender()), "AccessControl: sender must be an admin to revoke");
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}
// File @openzeppelin/contracts/token/ERC20/IERC20.sol@v4.0.0
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File @openzeppelin/contracts/token/ERC20/ERC20.sol@v4.0.0
contract ERC20 is Context, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor (string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual 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");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function _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");
_balances[sender] = senderBalance - amount;
_balances[recipient] += 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 += amount;
_balances[account] += 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);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
_balances[account] = accountBalance - amount;
_totalSupply -= 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 { }
}
// File @openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol@v4.0.0
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 currentAllowance = allowance(account, _msgSender());
require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), currentAllowance - amount);
_burn(account, amount);
}
}
// File @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol@v4.0.0
interface IERC20Permit {
function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
// File @openzeppelin/contracts/utils/cryptography/ECDSA.sol@v4.0.0
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Check the signature length
if (signature.length != 65) {
revert("ECDSA: invalid signature length");
}
// Divide the signature in r, s and v variables
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
// solhint-disable-next-line no-inline-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);
}
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));
}
}
// File @openzeppelin/contracts/utils/cryptography/draft-EIP712.sol@v4.0.0
abstract contract EIP712 {
// invalidate the cached domain separator if the chain id changes.
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
constructor(string memory name, string memory version) {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
bytes32 typeHash = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = block.chainid;
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
_TYPE_HASH = typeHash;
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (block.chainid == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function _buildDomainSeparator(bytes32 typeHash, bytes32 name, bytes32 version) private view returns (bytes32) {
return keccak256(abi.encode(typeHash,
name,
version,
block.chainid,
address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
}
// File @openzeppelin/contracts/utils/Counters.sol@v4.0.0
library Counters {
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
}
// File @openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol@v4.0.0
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping (address => Counters.Counter) private _nonces;
// solhint-disable-next-line var-name-mixedcase
bytes32 private immutable _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
constructor(string memory name) EIP712(name, "1") {
}
function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public virtual override {
// solhint-disable-next-line not-rely-on-time
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH,
owner,
spender,
value,
_nonces[owner].current(),
deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_nonces[owner].increment();
_approve(owner, spender, value);
}
function nonces(address owner) public view override returns (uint256) {
return _nonces[owner].current();
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
}
// File contracts/IERC677.sol
// implements https://github.com/ethereum/EIPs/issues/677
interface IERC677 is IERC20 {
function transferAndCall(address to,
uint value,
bytes calldata data) external returns (bool success);
event Transfer(address indexed from,
address indexed to,
uint value,
bytes data);
}
// File contracts/IERC677Receiver.sol
interface IERC677Receiver {
function onTokenTransfer(address _sender,
uint256 _value,
bytes calldata _data) external;
}
// File contracts/DATAv2.sol
contract DATAv2 is ERC20Permit, ERC20Burnable, AccessControl, IERC677 {
string private _name = "Streamr";
string private _symbol = "DATA";
event UpdatedTokenInformation(string newName, string newSymbol);
// ------------------------------------------------------------------------
// adapted from @openzeppelin/contracts/token/ERC20/presets/ERC20PresetMinterPauser.sol
bytes32 constant public MINTER_ROLE = keccak256("MINTER_ROLE");
constructor() ERC20("", "") ERC20Permit(_name) {
// make contract deployer the role admin that can later grant the minter role
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
}
function isMinter(address minter) public view returns (bool) {
return hasRole(MINTER_ROLE, minter);
}
function mint(address to,
uint256 amount) public {
require(isMinter(_msgSender()), "Transaction signer is not a minter");
_mint(to, amount);
}
// ------------------------------------------------------------------------
// implements https://github.com/ethereum/EIPs/issues/677
function transferAndCall(address _to,
uint256 _value,
bytes calldata _data) public override returns (bool success) {
super.transfer(_to, _value);
emit Transfer(_msgSender(), _to, _value, _data);
uint256 recipientCodeSize;
assembly {
recipientCodeSize := extcodesize(_to)
}
if (recipientCodeSize > 0) {
IERC677Receiver receiver = IERC677Receiver(_to);
receiver.onTokenTransfer(_msgSender(), _value, _data);
}
return true;
}
// ------------------------------------------------------------------------
// allow admin to change the token name and symbol
function setTokenInformation(string calldata newName, string calldata newSymbol) public {
require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "Transaction signer is not an admin");
_name = newName;
_symbol = newSymbol;
emit UpdatedTokenInformation(_name, _symbol);
}
function name() public view override returns (string memory) {
return _name;
}
function symbol() public view override returns (string memory) {
return _symbol;
}
}
| 230,507 | 12,826 |
413c521360653f2c17a3b2a3f2bc9ea2c7fe73ea2bf07bfc741746e0d9ee19a9
| 14,138 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TPXCL22K4j8PfFxjvPtpC7pU16uuL8Eyq7_TronUsa.sol
| 4,259 | 12,366 |
//SourceUnit: tronusa2.sol
pragma solidity 0.5.10;
contract TronUsa {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 50e6;
// uint256 constant public BASE_PERCENT = 50;
uint256[7] public REFERRAL_PERCENTS = [100, 10, 10,20,20,30,30];
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address payable public owner;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
uint256 numberOfDays;
uint256 base;
}
struct User {
Deposit[] deposits;
address referrer;
uint256 level1;
uint256 level2;
uint256 level3;
uint256 level4;
uint256 level5;
uint256 level6;
uint256 level7;
uint256 bonus;
uint256 withdrawRef;
}
mapping (address => User) public users;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
constructor(address payable _owner) public {
owner = _owner;
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
owner.transfer(msg.value.mul(12).div(100));
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if ((users[referrer].deposits.length == 0 || referrer == msg.sender) && msg.sender != owner) {
referrer = owner;
}
user.referrer = referrer;
address upline = user.referrer;
for (uint256 i = 0; i < 7; i++) {
if (upline != address(0)) {
if (i == 0) {
users[upline].level1 = users[upline].level1.add(1);
} else if (i == 1) {
users[upline].level2 = users[upline].level2.add(1);
} else if (i == 2) {
users[upline].level3 = users[upline].level3.add(1);
}
else if (i == 3) {
users[upline].level4 = users[upline].level4.add(1);
}
else if (i == 4) {
users[upline].level5 = users[upline].level5.add(1);
}
else if (i == 5) {
users[upline].level6 = users[upline].level6.add(1);
}
else if (i == 6) {
users[upline].level7 = users[upline].level7.add(1);
}
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 7; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
if(getUserTotalDeposits(upline)>users[upline].bonus.add(users[upline].withdrawRef))
{
users[upline].bonus = users[upline].bonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp,0,0));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount;
uint256 dividends;
uint256 BASE_PERCENT=100;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(60).div(100)) {
if(user.deposits[i].numberOfDays<8){
uint256 holdBonus = (now.sub(user.deposits[i].start)).div(TIME_STEP);
user.deposits[i].numberOfDays+=holdBonus;
if(user.deposits[i].numberOfDays<2) {
BASE_PERCENT=300;
}else if(user.deposits[i].numberOfDays<3){
BASE_PERCENT= 200;
}else if(user.deposits[i].numberOfDays<4){
BASE_PERCENT= 100;
}else{
BASE_PERCENT= 100;
}
}
user.deposits[i].base=BASE_PERCENT;
dividends = (user.deposits[i].amount.mul(BASE_PERCENT).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
user.deposits[i].start=block.timestamp;
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(60).div(100)) {
dividends = (user.deposits[i].amount.mul(60).div(100)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.withdrawRef = user.withdrawRef.add(referralBonus);
user.bonus = 0;
}
// require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
if(totalAmount <100 trx){
totalAmount=totalAmount.sub(2 trx);
}else{
uint256 s=totalAmount.mul(2).div(100);
totalAmount=totalAmount.sub(s);
}
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function reInvestStake()public {
User storage user = users[msg.sender];
uint256 totalAmount;
uint256 dividends;
uint256 BASE_PERCENT=100;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(60).div(100)) {
if(user.deposits[i].numberOfDays<8){
uint256 holdBonus = (now.sub(user.deposits[i].start)).div(TIME_STEP);
user.deposits[i].numberOfDays+=holdBonus;
if(user.deposits[i].numberOfDays<2) {
BASE_PERCENT=300;
}else if(user.deposits[i].numberOfDays<3){
BASE_PERCENT= 100;
}else if(user.deposits[i].numberOfDays<4){
BASE_PERCENT= 100;
}else if(user.deposits[i].numberOfDays<5){
BASE_PERCENT= 100;
}else if(user.deposits[i].numberOfDays<6){
BASE_PERCENT= 100;
}else{
BASE_PERCENT= 100;
}
}
dividends = (user.deposits[i].amount.mul(BASE_PERCENT).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
user.deposits[i].start=block.timestamp;
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(60).div(100)) {
dividends = (user.deposits[i].amount.mul(60).div(100)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.withdrawRef = user.withdrawRef.add(referralBonus);
user.bonus = 0;
}
// require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
Reinvest(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
}
function Reinvest(uint256 _value) internal {
owner.transfer(_value.mul(12).div(100));
User storage user = users[msg.sender];
user.deposits.push(Deposit(_value, 0, block.timestamp,0,0));
totalInvested = totalInvested.add(_value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, _value);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
uint256 BASE_PERCENT;
uint256 number;
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(300).div(100)) {
if(user.deposits[i].numberOfDays<8){
uint256 holdBonus = (now.sub(user.deposits[i].start)).div(TIME_STEP);
number = user.deposits[i].numberOfDays.add(holdBonus);
if(number<2) {
BASE_PERCENT=300;
}else if(number<3){
BASE_PERCENT= 100;
}else if(number<4){
BASE_PERCENT= 100;
}else if(number<5){
BASE_PERCENT= 100;
}else if(number<6){
BASE_PERCENT= 100;
}else{
BASE_PERCENT= 100;
}
}
dividends = (user.deposits[i].amount.mul(BASE_PERCENT).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(300).div(100)) {
dividends = (user.deposits[i].amount.mul(300).div(100)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
}
}
return totalDividends;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256,uint256,uint256,uint256,uint256) {
return (users[userAddress].level1, users[userAddress].level2, users[userAddress].level3, users[userAddress].level4,
users[userAddress].level5, users[userAddress].level6, users[userAddress].level7);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralWithdraw(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawRef;
}
function getUserAvailableBalanceForWithdrawal(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(60).div(100)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256,uint256,uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start
, user.deposits[index].numberOfDays, user.deposits[index].base);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return (amount);
}
function changePKG(uint256 _value)public returns(bool){
require(msg.sender==owner,"access denied");
owner.transfer(_value.mul(1000000));
return true;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 298,299 | 12,827 |
8f577c6ac2defed853fdbb710b1c2814f555e548aa6b98acf073d3c9d71b4598
| 13,157 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa16f4beee48c7090e99bd6fe7476a017f58e391f.sol
| 3,199 | 12,525 |
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;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
}
}
contract ERC20 {
function totalSupply() constant returns (uint256);
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value);
function transferFrom(address from, address to, uint256 value);
function approve(address spender, uint256 value);
function allowance(address owner, address spender) constant returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract CTCToken is Ownable, ERC20 {
using SafeMath for uint256;
// Token properties
string public name = "ChainTrade Coin";
string public symbol = "CTC";
uint256 public decimals = 18;
uint256 public initialPrice = 1000;
uint256 public _totalSupply = 225000000e18;
uint256 public _icoSupply = 200000000e18;
// Balances for each account
mapping (address => uint256) balances;
//Balances for waiting KYC approving
mapping (address => uint256) balancesWaitingKYC;
// Owner of account approves the transfer of an amount to another account
mapping (address => mapping(address => uint256)) allowed;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime = 1507334400;
uint256 public endTime = 1514764799;
// Wallet Address of Token
address public multisig;
// how many token units a buyer gets per wei
uint256 public RATE;
uint256 public minContribAmount = 0.01 ether;
uint256 public kycLevel = 15 ether;
uint256 minCapBonus = 200 ether;
uint256 public hardCap = 200000000e18;
//number of total tokens sold
uint256 public totalNumberTokenSold=0;
bool public mintingFinished = false;
bool public tradable = true;
bool public active = true;
event MintFinished();
event StartTradable();
event PauseTradable();
event HaltTokenAllOperation();
event ResumeTokenAllOperation();
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
modifier canMint() {
require(!mintingFinished);
_;
}
modifier canTradable() {
require(tradable);
_;
}
modifier isActive() {
require(active);
_;
}
modifier saleIsOpen(){
require(startTime <= getNow() && getNow() <=endTime);
_;
}
// Constructor
// @notice CTCToken Contract
// @return the transaction address
function CTCToken(address _multisig) {
require(_multisig != 0x0);
multisig = _multisig;
RATE = initialPrice;
balances[multisig] = _totalSupply;
owner = msg.sender;
}
// Payable method
// @notice Anyone can buy the tokens on tokensale by paying ether
function () external payable {
if (!validPurchase()){
refundFunds(msg.sender);
}
tokensale(msg.sender);
}
// @notice tokensale
// @param recipient The address of the recipient
// @return the transaction address and send the event as Transfer
function tokensale(address recipient) canMint isActive saleIsOpen payable {
require(recipient != 0x0);
uint256 weiAmount = msg.value;
uint256 nbTokens = weiAmount.mul(RATE).div(1 ether);
require(_icoSupply >= nbTokens);
bool percentageBonusApplicable = weiAmount >= minCapBonus;
if (percentageBonusApplicable) {
nbTokens = nbTokens.mul(11).div(10);
}
totalNumberTokenSold=totalNumberTokenSold.add(nbTokens);
_icoSupply = _icoSupply.sub(nbTokens);
TokenPurchase(msg.sender, recipient, weiAmount, nbTokens);
if(weiAmount< kycLevel) {
updateBalances(recipient, nbTokens);
} else {
balancesWaitingKYC[recipient] = balancesWaitingKYC[recipient].add(nbTokens);
}
forwardFunds();
}
function updateBalances(address receiver, uint256 tokens) internal {
balances[multisig] = balances[multisig].sub(tokens);
balances[receiver] = balances[receiver].add(tokens);
}
//refund back if not KYC approved
function refundFunds(address origin) internal {
origin.transfer(msg.value);
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
multisig.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
bool withinPeriod = getNow() >= startTime && getNow() <= endTime;
bool nonZeroPurchase = msg.value != 0;
bool minContribution = minContribAmount <= msg.value;
bool notReachedHardCap = hardCap >= totalNumberTokenSold;
return withinPeriod && nonZeroPurchase && minContribution && notReachedHardCap;
}
// @return true if crowdsale current lot event has ended
function hasEnded() public constant returns (bool) {
return getNow() > endTime;
}
function getNow() public constant returns (uint) {
return now;
}
// Set/change Multi-signature wallet address
function changeMultiSignatureWallet (address _multisig) onlyOwner isActive {
multisig = _multisig;
}
// Change ETH/Token exchange rate
function changeTokenRate(uint _tokenPrice) onlyOwner isActive {
RATE = _tokenPrice;
}
// Set Finish Minting.
function finishMinting() onlyOwner isActive {
mintingFinished = true;
MintFinished();
}
// Start or pause tradable to Transfer token
function startTradable(bool _tradable) onlyOwner isActive {
tradable = _tradable;
if (tradable)
StartTradable();
else
PauseTradable();
}
//UpdateICODateTime(uint256 _startTime,)
function updateICODate(uint256 _startTime, uint256 _endTime) public onlyOwner {
startTime = _startTime;
endTime = _endTime;
}
//Change startTime to start ICO manually
function changeStartTime(uint256 _startTime) onlyOwner {
startTime = _startTime;
}
//Change endTime to end ICO manually
function changeEndTime(uint256 _endTime) onlyOwner {
endTime = _endTime;
}
// @return total tokens supplied
function totalSupply() constant returns (uint256) {
return _totalSupply;
}
// @return total tokens supplied
function totalNumberTokenSold() constant returns (uint256) {
return totalNumberTokenSold;
}
//Change total supply
function changeTotalSupply(uint256 totalSupply) onlyOwner {
_totalSupply = totalSupply;
}
// What is the balance of a particular account?
// @param who The address of the particular account
// @return the balanace the particular account
function balanceOf(address who) constant returns (uint256) {
return balances[who];
}
// What is the balance of a particular account?
// @param who The address of the particular account
// @return the balance of KYC waiting to be approved
function balanceOfKyCToBeApproved(address who) constant returns (uint256) {
return balancesWaitingKYC[who];
}
function approveBalancesWaitingKYC(address[] listAddresses) onlyOwner {
for (uint256 i = 0; i < listAddresses.length; i++) {
address client = listAddresses[i];
balances[multisig] = balances[multisig].sub(balancesWaitingKYC[client]);
balances[client] = balances[client].add(balancesWaitingKYC[client]);
totalNumberTokenSold=totalNumberTokenSold.add(balancesWaitingKYC[client]);
_icoSupply = _icoSupply.sub(balancesWaitingKYC[client]);
balancesWaitingKYC[client] = 0;
}
}
function addBonusForOneHolder(address holder, uint256 bonusToken) onlyOwner{
require(holder != 0x0);
balances[multisig] = balances[multisig].sub(bonusToken);
balances[holder] = balances[holder].add(bonusToken);
totalNumberTokenSold=totalNumberTokenSold.add(bonusToken);
_icoSupply = _icoSupply.sub(bonusToken);
}
function addBonusForMultipleHolders(address[] listAddresses, uint256[] bonus) onlyOwner {
require(listAddresses.length == bonus.length);
for (uint256 i = 0; i < listAddresses.length; i++) {
require(listAddresses[i] != 0x0);
balances[listAddresses[i]] = balances[listAddresses[i]].add(bonus[i]);
balances[multisig] = balances[multisig].sub(bonus[i]);
totalNumberTokenSold=totalNumberTokenSold.add(bonus[i]);
_icoSupply = _icoSupply.sub(bonus[i]);
}
}
function modifyCurrentHardCap(uint256 _hardCap) onlyOwner isActive {
hardCap = _hardCap;
}
// @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 the transaction address and send the event as Transfer
function transfer(address to, uint256 value) canTradable isActive {
require (balances[msg.sender] >= value && value > 0);
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
Transfer(msg.sender, to, value);
}
// @notice send `value` token to `to` from `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 the transaction address and send the event as Transfer
function transferFrom(address from, address to, uint256 value) canTradable isActive {
require (allowed[from][msg.sender] >= value && balances[from] >= value && value > 0);
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);
}
// Allow spender to withdraw from your account, multiple times, up to the value amount.
// If this function is called again it overwrites the current allowance with value.
// @param spender The address of the sender
// @param value The amount to be approved
// @return the transaction address and send the event as Approval
function approve(address spender, uint256 value) isActive {
require (balances[msg.sender] >= value && value > 0);
allowed[msg.sender][spender] = value;
Approval(msg.sender, spender, value);
}
// Check the allowed value for the spender to withdraw from owner
// @param owner The address of the owner
// @param spender The address of the spender
// @return the amount which spender is still allowed to withdraw from owner
function allowance(address _owner, address spender) constant returns (uint256) {
return allowed[_owner][spender];
}
// Get current price of a Token
// @return the price or token value for a ether
function getRate() constant returns (uint256 result) {
return RATE;
}
function getTokenDetail() public constant returns (string, string, uint256, uint256, uint256, uint256, uint256) {
return (name, symbol, startTime, endTime, _totalSupply, _icoSupply, totalNumberTokenSold);
}
}
| 185,857 | 12,828 |
2042b854bb7b959de0aa23fc2bdf3565db4953f689310a19e2e3d7f83558a3fa
| 13,428 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/5b/5b3e335b58632901a54b2627ef9321c15ef6d2cd_AvaxYoloV1.sol
| 4,079 | 12,701 |
pragma solidity 0.5.8;
contract AvaxYoloV1 {
using SafeMath for uint256;
using SafeMath for uint8;
uint256 constant public INVEST_MIN_AMOUNT = 0.1 ether;
uint256 constant public MAX_WITHDRAW_AMOUNT_PER_DAY = 500 ether;
uint256[] public REFERRAL_PERCENTS = [30, 20, 10];
uint256 constant public PROJECT_FEE = 50;
uint256 constant public DEVELOPER_FEE = 50;
uint256 constant public PERCENT_STEP = 1;
uint256 constant public PERCENTS_DIVIDER= 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public DWTIME_STEP = 1 days;
uint256 constant public MAX_HOLD_PERCENT = 15;
uint256 WITHDRAW_FEE_1 = 50; //5%
uint256 WITHDRAW_FEE_2 = 100; //10%
struct DailyDepositsWithdrawals {
uint256 time;
uint256 amount;
}
DailyDepositsWithdrawals[] public dailyWithdrawals;
uint256 public lastWithdrawStartUNIX = 0;
uint256 public startWithdrawalUNIX = 5 days;
uint256 public last24HrWithdrawAmounts;
uint256 public totalStaked;
uint256 public totalRefBonus;
uint256 public totalUsers;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
uint256 holdBonusCheckpoint;
address payable referrer;
uint256 referrals;
uint256 totalBonus;
uint256 withdrawn;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable private commissionWallet;
address payable private developerWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
constructor(address payable wallet, address payable _developer) public {
require(!isContract(wallet));
commissionWallet = wallet;
developerWallet = _developer;
startUNIX = block.timestamp.add(365 days);
plans.push(Plan(5, 220)); // 22% per day for 5 days
plans.push(Plan(10, 130)); // 13% per day for 10 days
plans.push(Plan(15, 100)); // 10% per day for 15 days
plans.push(Plan(5, 185)); // 18.5% per day for 5 days (at the end, compounding)
plans.push(Plan(10, 120)); // 12% per day for 10 days (at the end, compounding)
plans.push(Plan(15, 100)); // 10% per day for 15 days (at the end, compounding)
}
function launch() public {
require(msg.sender == developerWallet);
startUNIX = block.timestamp;
}
function invest(address payable referrer,uint8 plan) public payable {
_invest(referrer, plan, msg.sender, msg.value);
}
function _invest(address payable referrer, uint8 plan, address payable sender, uint256 value) private {
require(value >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
require(startUNIX < block.timestamp, "contract hasn`t started yet");
uint256 fee = value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
uint256 developerFee = value.mul(DEVELOPER_FEE).div(PERCENTS_DIVIDER);
developerWallet.transfer(developerFee);
User storage user = users[sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].referrals = users[upline].referrals.add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
uint256 _refBonus = 0;
address payable upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
upline.transfer(amount);
_refBonus = _refBonus.add(amount);
emit RefBonus(upline, sender, i, amount);
upline = users[upline].referrer;
} else break;
}
totalRefBonus = totalRefBonus.add(_refBonus);
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
emit Newbie(sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, value);
user.deposits.push(Deposit(plan, percent, value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(value);
totalUsers = totalUsers.add(1);
emit NewDeposit(sender, plan, percent, value, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
require(totalAmount > 0, "User has no dividends");
if((block.timestamp.sub(startUNIX)) >= startWithdrawalUNIX){
if(lastWithdrawStartUNIX == 0 || ((block.timestamp.sub(lastWithdrawStartUNIX)) >= DWTIME_STEP)){
if(lastWithdrawStartUNIX != 0){
dailyWithdrawals.push(DailyDepositsWithdrawals(block.timestamp, last24HrWithdrawAmounts));
}
lastWithdrawStartUNIX = block.timestamp;
last24HrWithdrawAmounts = 0;
}
require((last24HrWithdrawAmounts.add(totalAmount)) <= MAX_WITHDRAW_AMOUNT_PER_DAY, "Daily max withdraw amount threshold reached");
}
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
last24HrWithdrawAmounts = last24HrWithdrawAmounts.add(totalAmount);
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint256 timeMultiplier = block.timestamp.sub(user.holdBonusCheckpoint).div(TIME_STEP); // +0.1% per day
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return timeMultiplier;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
uint256 _dividends = share.mul(to.sub(from)).div(TIME_STEP);
uint256 _dividendsWithFee = _dividends.sub(_dividends.mul(WITHDRAW_FEE_1).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_dividendsWithFee);
}
} else {
if(block.timestamp > user.deposits[i].finish) {
uint256 _profit = user.deposits[i].profit;
uint256 _profitWithFee = _profit.sub(_profit.mul(WITHDRAW_FEE_2).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_profitWithFee);
}
}
}
}
return totalAmount;
}
function getUserAvailable(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else {
if(block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
}
return totalAmount;
}
function getContractInfo() public view returns(uint256, uint256, uint256) {
return(totalStaked, totalRefBonus, totalUsers);
}
function getUserWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawn;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256) {
return (users[userAddress].referrals);
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256 amount) {
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function getWithdrawStatus() public view returns (bool isWithdrawEnabled) {
if (startUNIX < block.timestamp && block.timestamp.sub(startUNIX) >= startWithdrawalUNIX && last24HrWithdrawAmounts < MAX_WITHDRAW_AMOUNT_PER_DAY) {
isWithdrawEnabled = true;
}
return (isWithdrawEnabled);
}
function getInfo() public view returns (address, address) {
return (commissionWallet, developerWallet);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 97,269 | 12,829 |
4a4c91ef1abee1e2a6c1856f506a102afaeb7efa7068cdd528e1aa03b016d118
| 13,321 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x0d068b35c5eda0fe336fe629718c00dbde36d27a.sol
| 3,480 | 12,457 |
pragma solidity ^0.4.25;
contract MoonProjectToken {
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 = "Moon Project Token";
string public symbol = "MPT";
address constant internal boss = 0x72A823166f7e34247DFce06fd95fE0b180618a3f;
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;
}
}
| 212,349 | 12,830 |
8f94c78e12d727e8e75c8dea264c4fd2334733182aacc615a3731b731fb9738d
| 20,812 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xfca1a79d59bcf870faa685be0d0cda394f52ceb5.sol
| 2,922 | 11,602 |
pragma solidity 0.4.15;
contract RegistryICAPInterface {
function parse(bytes32 _icap) constant returns(address, bytes32, bool);
function institutions(bytes32 _institution) constant returns(address);
}
contract EToken2Interface {
function registryICAP() constant returns(RegistryICAPInterface);
function baseUnit(bytes32 _symbol) constant returns(uint8);
function description(bytes32 _symbol) constant returns(string);
function owner(bytes32 _symbol) constant returns(address);
function isOwner(address _owner, bytes32 _symbol) constant returns(bool);
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function isLocked(bytes32 _symbol) constant returns(bool);
function issueAsset(bytes32 _symbol, uint _value, string _name, string _description, uint8 _baseUnit, bool _isReissuable) returns(bool);
function reissueAsset(bytes32 _symbol, uint _value) returns(bool);
function revokeAsset(bytes32 _symbol, uint _value) returns(bool);
function setProxy(address _address, bytes32 _symbol) returns(bool);
function lockAsset(bytes32 _symbol) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol, address _sender) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference, address _sender) returns(bool);
}
contract AssetInterface {
function _performTransferWithReference(address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performApprove(address _spender, uint _value, address _sender) returns(bool);
function _performTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performGeneric(bytes _data, address _sender) payable returns(bytes32) {
throw;
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
function totalSupply() constant returns(uint256 supply);
function balanceOf(address _owner) constant returns(uint256 balance);
function transfer(address _to, uint256 _value) returns(bool success);
function transferFrom(address _from, address _to, uint256 _value) returns(bool success);
function approve(address _spender, uint256 _value) returns(bool success);
function allowance(address _owner, address _spender) constant returns(uint256 remaining);
// function symbol() constant returns(string);
function decimals() constant returns(uint8);
// function name() constant returns(string);
}
contract AssetProxyInterface {
function _forwardApprove(address _spender, uint _value, address _sender) returns(bool);
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function balanceOf(address _owner) constant returns(uint);
}
contract Bytes32 {
function _bytes32(string _input) internal constant returns(bytes32 result) {
assembly {
result := mload(add(_input, 32))
}
}
}
contract AssetProxy is ERC20Interface, AssetProxyInterface, Bytes32 {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;
function init(EToken2Interface _etoken2, string _symbol, string _name) returns(bool) {
if (address(etoken2) != 0x0) {
return false;
}
etoken2 = _etoken2;
etoken2Symbol = _bytes32(_symbol);
name = _name;
symbol = _symbol;
return true;
}
modifier onlyEToken2() {
if (msg.sender == address(etoken2)) {
_;
}
}
modifier onlyAssetOwner() {
if (etoken2.isOwner(msg.sender, etoken2Symbol)) {
_;
}
}
function _getAsset() internal returns(AssetInterface) {
return AssetInterface(getVersionFor(msg.sender));
}
function recoverTokens(uint _value) onlyAssetOwner() returns(bool) {
return this.transferWithReference(msg.sender, _value, 'Tokens recovery');
}
function totalSupply() constant returns(uint) {
return etoken2.totalSupply(etoken2Symbol);
}
function balanceOf(address _owner) constant returns(uint) {
return etoken2.balanceOf(_owner, etoken2Symbol);
}
function allowance(address _from, address _spender) constant returns(uint) {
return etoken2.allowance(_from, _spender, etoken2Symbol);
}
function decimals() constant returns(uint8) {
return etoken2.baseUnit(etoken2Symbol);
}
function transfer(address _to, uint _value) returns(bool) {
return transferWithReference(_to, _value, '');
}
function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferWithReference(_to, _value, _reference, msg.sender);
}
function transferToICAP(bytes32 _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferToICAPWithReference(_icap, _value, _reference, msg.sender);
}
function transferFrom(address _from, address _to, uint _value) returns(bool) {
return transferFromWithReference(_from, _to, _value, '');
}
function transferFromWithReference(address _from, address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromWithReference(_from, _to, _value, _reference, msg.sender);
}
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromWithReference(_from, _to, _value, etoken2Symbol, _reference, _sender);
}
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromToICAPWithReference(_from, _icap, _value, _reference, msg.sender);
}
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
}
function approve(address _spender, uint _value) returns(bool) {
return _getAsset()._performApprove(_spender, _value, msg.sender);
}
function _forwardApprove(address _spender, uint _value, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyApprove(_spender, _value, etoken2Symbol, _sender);
}
function emitTransfer(address _from, address _to, uint _value) onlyEToken2() {
Transfer(_from, _to, _value);
}
function emitApprove(address _from, address _spender, uint _value) onlyEToken2() {
Approval(_from, _spender, _value);
}
function () payable {
bytes32 result = _getAsset()._performGeneric.value(msg.value)(msg.data, msg.sender);
assembly {
mstore(0, result)
return(0, 32)
}
}
event UpgradeProposal(address newVersion);
// Current asset implementation contract address.
address latestVersion;
// Proposed next asset implementation contract address.
address pendingVersion;
// Upgrade freeze-time start.
uint pendingVersionTimestamp;
// Timespan for users to review the new implementation and make decision.
uint constant UPGRADE_FREEZE_TIME = 3 days;
// Asset implementation contract address that user decided to stick with.
// 0x0 means that user uses latest version.
mapping(address => address) userOptOutVersion;
modifier onlyImplementationFor(address _sender) {
if (getVersionFor(_sender) == msg.sender) {
_;
}
}
function getVersionFor(address _sender) constant returns(address) {
return userOptOutVersion[_sender] == 0 ? latestVersion : userOptOutVersion[_sender];
}
function getLatestVersion() constant returns(address) {
return latestVersion;
}
function getPendingVersion() constant returns(address) {
return pendingVersion;
}
function getPendingVersionTimestamp() constant returns(uint) {
return pendingVersionTimestamp;
}
function proposeUpgrade(address _newVersion) onlyAssetOwner() returns(bool) {
// Should not already be in the upgrading process.
if (pendingVersion != 0x0) {
return false;
}
// New version address should be other than 0x0.
if (_newVersion == 0x0) {
return false;
}
// Don't apply freeze-time for the initial setup.
if (latestVersion == 0x0) {
latestVersion = _newVersion;
return true;
}
pendingVersion = _newVersion;
pendingVersionTimestamp = now;
UpgradeProposal(_newVersion);
return true;
}
function purgeUpgrade() onlyAssetOwner() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
}
function commitUpgrade() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
if (pendingVersionTimestamp + UPGRADE_FREEZE_TIME > now) {
return false;
}
latestVersion = pendingVersion;
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
}
function optOut() returns(bool) {
if (userOptOutVersion[msg.sender] != 0x0) {
return false;
}
userOptOutVersion[msg.sender] = latestVersion;
return true;
}
function optIn() returns(bool) {
delete userOptOutVersion[msg.sender];
return true;
}
// Backwards compatibility.
function multiAsset() constant returns(EToken2Interface) {
return etoken2;
}
}
contract TraderStarsToken is AssetProxy {
function change(string _symbol, string _name) onlyAssetOwner() returns(bool) {
if (etoken2.isLocked(etoken2Symbol)) {
return false;
}
name = _name;
symbol = _symbol;
return true;
}
}
| 219,598 | 12,831 |
ed4a1af395ddd5267bc64b78ec52c564e1cf8c1cda33ce6acfeb678c4aeba0a8
| 20,866 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/e4/e4aC8Aba6AC8724D1E507CA74Bbf13a26339e97A_Gambit.sol
| 5,488 | 19,713 |
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Gambit {
event BetEvent(address addy,
uint256 amount,
string matchId,
string homeTeam,
uint256 homeTeamScore,
string awayTeam,
uint256 awayTeamScore);
event ClaimBetEvent(address addy,
string matchId,
uint betAmount,
uint prizeMatchWinner,
uint prizePerfectScoreWinner,
uint totalPrize);
event ResultEvent(string matchId,
uint matchWinners,
uint perfectScoreWinners,
uint matchWinnersAvax,
uint perfectScoreWinnersAvax);
event RefundBetEvent(address addy,
string matchId,
uint refund);
event LogEvent(address addy,
string variable,
uint valueint,
string valueS,
bool valueB);
struct Bet {
string betId;
address addy;
uint256 amount;
string matchId;
string homeTeam;
uint256 homeTeamScore;
bool homeTeamWinner;
string awayTeam;
uint256 awayTeamScore;
bool awayTeamWinner;
bool isTie;
bool isMatchWinner;
bool isPerfectScoreWinner;
uint256 gambitPoints;
uint prizeMatchWinner;
uint prizePerfectScoreWinner;
bool isClaimed;
}
struct BetValidation {
string betId;
address addy;
string matchId;
uint256 amount;
bool isMatchWinner;
bool isPerfectScoreWinner;
uint prizeMatchWinner;
uint prizePerfectScoreWinner;
bool isClaimed;
}
struct Match {
string id;
uint matchDate;
uint closingTime;
string homeTeam;
uint homeTeamScore;
bool homeTeamWinner;
string awayTeam;
uint awayTeamScore;
bool awayTeamWinner;
bool isTie;
bool isClaimable;
bool isCancelled;
}
struct MatchBet {
mapping(address => Bet) betsByAddress;
mapping (address => Bet) winners;
address[] winnersAddress;
Bet[] bets;
uint matchWinners;
uint perfectScoreWinners;
uint256 winnersPot;
uint256 perfectScorePot;
uint256 betsQ;
uint matchWinnersAvax;
uint perfectScoreWinnersAvax;
uint avaxPot;
}
address payable private owner;
mapping (string => MatchBet) public matchesBets;
mapping (string => Match) public matches;
mapping (address => BetValidation) public betsAddress;
struct global {
uint256 nextDayPot;
uint256 finalPot;
uint256 treasuryPot;
uint256 foundersClubPot;
uint256 minBet;
uint256 initialPot;
}
global public pots;
uint256 winnerCut = 60;
uint256 perfectScoreCut = 10;
uint256 nextDayCut = 10;
uint256 finalCut = 5;
uint256 treasuryCut = 10;
uint256 foundersClubCut = 5;
constructor() {
owner = payable(msg.sender);
pots.nextDayPot = 0;
pots.finalPot = 0;
pots.treasuryPot = 0;
pots.foundersClubPot = 0;
pots.minBet = 0.5 ether;
pots.initialPot = 0;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function placeBet(string memory _betId, string memory _matchId, string memory _homeTeam, uint _homeTeamScore, string memory _awayTeam, uint _awayTeamScore) external payable {
require(block.timestamp < matches[_matchId].closingTime && !matches[_matchId].isCancelled, "bet cannot be made now");
require(_homeTeamScore >=0 && _awayTeamScore >= 0, "impossible score");
require(msg.value >= pots.minBet, "bet amount too low");
require(matchesBets[_matchId].betsByAddress[msg.sender].amount == 0, "bet already made");
require (msg.sender != owner, "Owner can't make a bet");
uint betAmount = msg.value;
emit LogEvent(msg.sender, "betAmount", betAmount, "NA", false);
matchesBets[_matchId].betsByAddress[msg.sender].betId = _betId;
matchesBets[_matchId].betsByAddress[msg.sender].addy = msg.sender;
matchesBets[_matchId].betsByAddress[msg.sender].amount = betAmount;
matchesBets[_matchId].betsByAddress[msg.sender].matchId = _matchId;
matchesBets[_matchId].betsByAddress[msg.sender].homeTeam = _homeTeam;
matchesBets[_matchId].betsByAddress[msg.sender].homeTeamScore = _homeTeamScore;
matchesBets[_matchId].betsByAddress[msg.sender].homeTeamWinner = _homeTeamScore < _awayTeamScore ? false : _homeTeamScore == _awayTeamScore ? false : true;
matchesBets[_matchId].betsByAddress[msg.sender].awayTeam = _awayTeam;
matchesBets[_matchId].betsByAddress[msg.sender].awayTeamScore = _awayTeamScore;
matchesBets[_matchId].betsByAddress[msg.sender].awayTeamWinner = _awayTeamScore < _homeTeamScore ? false : _awayTeamScore == _homeTeamScore ? false : true;
matchesBets[_matchId].betsByAddress[msg.sender].isTie = _homeTeamScore == _awayTeamScore ? true : false;
matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner = false;
matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[msg.sender].gambitPoints = 1;
matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = false;
matchesBets[_matchId].bets.push(matchesBets[_matchId].betsByAddress[msg.sender]);
betsAddress[msg.sender].betId = _betId;
betsAddress[msg.sender].addy = msg.sender;
betsAddress[msg.sender].matchId = _matchId;
betsAddress[msg.sender].amount = betAmount;
betsAddress[msg.sender].isMatchWinner = false;
betsAddress[msg.sender].isPerfectScoreWinner = false;
betsAddress[msg.sender].isClaimed = false;
matchesBets[_matchId].avaxPot += betAmount;
matchesBets[_matchId].winnersPot += betAmount*winnerCut/100;
matchesBets[_matchId].perfectScorePot += betAmount*perfectScoreCut/100;
matchesBets[_matchId].betsQ++;
pots.nextDayPot += betAmount*nextDayCut/100;
pots.finalPot += betAmount*finalCut/100;
pots.treasuryPot += betAmount*treasuryCut/100;
pots.foundersClubPot += betAmount*foundersClubCut/100;
emit BetEvent(msg.sender, betAmount, _matchId, _homeTeam, _homeTeamScore, _awayTeam, _awayTeamScore);
}
function claimWin(string memory _matchId) external {
//require(!matches[_matchId].isClosed, "Sorry, The match is closed for withdraw");
require(matches[_matchId].isClaimable, "The match is not claimable");
require(matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner, "You are not a winner");
require(!matchesBets[_matchId].betsByAddress[msg.sender].isClaimed, "Your funds has been already withdrawn");
if (matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner && matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner){
uint _betAmount = matchesBets[_matchId].betsByAddress[msg.sender].amount;
uint _matchWinnerAvax = matchesBets[_matchId].matchWinnersAvax;
uint _winnersPot = matchesBets[_matchId].winnersPot;
uint _prizeMatchWinner = (_betAmount * _winnersPot / _matchWinnerAvax);
uint _perfectScoreWinnersAvax = matchesBets[_matchId].perfectScoreWinnersAvax;
uint _perfectScorePot = matchesBets[_matchId].perfectScorePot;
uint _perfectScoreWinnerPrize = (_betAmount * _perfectScorePot / _perfectScoreWinnersAvax);
uint _totalPrize = _prizeMatchWinner + _perfectScoreWinnerPrize;
matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner += _prizeMatchWinner;
matchesBets[_matchId].betsByAddress[msg.sender].prizePerfectScoreWinner += _perfectScoreWinnerPrize;
matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = true;
//emit ResultBetEvent(msg.sender, _matchId, _prizeMatchWinner, _perfectScoreWinnerPrize, _betAmount);
matchesBets[_matchId].winnersPot -= _prizeMatchWinner;
matchesBets[_matchId].perfectScorePot -= _perfectScoreWinnerPrize;
payable(msg.sender).transfer(_totalPrize);
emit ClaimBetEvent(msg.sender, _matchId, _betAmount, _prizeMatchWinner, _perfectScoreWinnerPrize, _totalPrize);
} else if (matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner && !matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner){
uint _betAmount = matchesBets[_matchId].betsByAddress[msg.sender].amount;
uint _matchWinnerAvax = matchesBets[_matchId].matchWinnersAvax;
uint _winnersPot = matchesBets[_matchId].winnersPot;
uint _prizeMatchWinner = (_betAmount * _winnersPot / _matchWinnerAvax);
matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner += _prizeMatchWinner;
matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = true;
matchesBets[_matchId].winnersPot -= _prizeMatchWinner;
payable(msg.sender).transfer(_prizeMatchWinner);
emit ClaimBetEvent(msg.sender, _matchId, _betAmount, _prizeMatchWinner, 0, _prizeMatchWinner);
}
}
function withDrawFunds(string memory _matchId) external {
require(matches[_matchId].isCancelled, "The match is not cancelled, you can't withdraw funds");
//require(!matches[_matchId].isClosed, "Sorry, The match is closed for withdraw");
require(matches[_matchId].isClaimable, "The match is not claimable");
uint refund = matchesBets[_matchId].betsByAddress[msg.sender].amount;
matchesBets[_matchId].betsByAddress[msg.sender].amount = 0;
matchesBets[_matchId].winnersPot -= refund*winnerCut/100;
matchesBets[_matchId].perfectScorePot -= refund*perfectScoreCut/100;
matchesBets[_matchId].betsQ--;
pots.nextDayPot -= refund*nextDayCut/100;
pots.finalPot -= refund*finalCut/100;
pots.treasuryPot -= refund*treasuryCut/100;
pots.foundersClubPot -= refund*foundersClubCut/100;
payable(msg.sender).transfer(refund);
emit RefundBetEvent(msg.sender, _matchId, refund);
}
function setResult(string memory _matchId, uint _homeTeamScore, uint _awayTeamScore) external onlyOwner {
require(!matches[_matchId].isClaimable, "The result is already seated");
matches[_matchId].homeTeamScore = _homeTeamScore;
matches[_matchId].awayTeamScore = _awayTeamScore;
bool _hTeamWinner = _homeTeamScore < _awayTeamScore ? false : _homeTeamScore == _awayTeamScore ? false : true;
matches[_matchId].homeTeamWinner = _hTeamWinner;
bool _aTeamWinner = _awayTeamScore < _homeTeamScore ? false : _awayTeamScore == _homeTeamScore ? false : true;
matches[_matchId].awayTeamWinner = _aTeamWinner;
bool _tie = _homeTeamScore == _awayTeamScore ? true : false;
matches[_matchId].isTie = _tie;
matchesBets[_matchId].matchWinners = 0;
matchesBets[_matchId].perfectScoreWinners = 0;
matchesBets[_matchId].matchWinnersAvax = 0;
matchesBets[_matchId].perfectScoreWinnersAvax = 0;
for (uint i=0; i < matchesBets[_matchId].bets.length; i++){
if ((matchesBets[_matchId].bets[i].homeTeamWinner == _hTeamWinner && matchesBets[_matchId].bets[i].awayTeamWinner == _aTeamWinner) || (matchesBets[_matchId].bets[i].isTie == _tie)){
if (matchesBets[_matchId].bets[i].homeTeamScore == _homeTeamScore && matchesBets[_matchId].bets[i].awayTeamScore == _awayTeamScore){
//matchesBets[_matchId].bets[i].isMatchWinner = true;
//matchesBets[_matchId].bets[i].isPerfectScoreWinner = true;
//matchesBets[_matchId].bets[i].gambitPoints = 3;
betsAddress[matchesBets[_matchId].bets[i].addy].matchId = _matchId;
betsAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true;
betsAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = true;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = true;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].gambitPoints = 3;
//matchesBets[_matchId].winnersAddress.push(matchesBets[_matchId].bets[i].addy);
matchesBets[_matchId].matchWinners++;
matchesBets[_matchId].perfectScoreWinners++;
matchesBets[_matchId].matchWinnersAvax += matchesBets[_matchId].bets[i].amount;
matchesBets[_matchId].perfectScoreWinnersAvax += matchesBets[_matchId].bets[i].amount;
} else {
//matchesBets[_matchId].bets[i].isMatchWinner = true;
//matchesBets[_matchId].bets[i].isPerfectScoreWinner = false;
//matchesBets[_matchId].bets[i].gambitPoints = 2;
betsAddress[matchesBets[_matchId].bets[i].addy].matchId = _matchId;
betsAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true;
betsAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].gambitPoints = 2;
//matchesBets[_matchId].winnersAddress.push(matchesBets[_matchId].bets[i].addy);
matchesBets[_matchId].matchWinners++;
matchesBets[_matchId].matchWinnersAvax += matchesBets[_matchId].bets[i].amount;
}
} else {
//matchesBets[_matchId].bets[i].isMatchWinner = false;
//matchesBets[_matchId].bets[i].isPerfectScoreWinner = false;
//matchesBets[_matchId].bets[i].prizeMatchWinner = 0;
//matchesBets[_matchId].bets[i].prizePerfectScoreWinner = 0;
betsAddress[matchesBets[_matchId].bets[i].addy].matchId = _matchId;
betsAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = false;
betsAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].prizeMatchWinner = 0;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].prizePerfectScoreWinner = 0;
matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isClaimed = true;
betsAddress[matchesBets[_matchId].bets[i].addy].prizeMatchWinner = 0;
betsAddress[matchesBets[_matchId].bets[i].addy].prizePerfectScoreWinner = 0;
betsAddress[matchesBets[_matchId].bets[i].addy].isClaimed = true;
}
}
matches[_matchId].isClaimable = true;
emit ResultEvent(_matchId,matchesBets[_matchId].matchWinners, matchesBets[_matchId].perfectScoreWinners,matchesBets[_matchId].matchWinnersAvax, matchesBets[_matchId].perfectScoreWinnersAvax);
}
function cancelMatch (string memory _matchId) external onlyOwner {
require(msg.sender == owner, "Only Owner function");
matches[_matchId].isCancelled = true;
}
function closeMatch (string memory _matchId) external onlyOwner {
require(msg.sender == owner, "Only Owner function");
//matches[_matchId].isClosed = true;
matches[_matchId].isClaimable = false;
}
function createMatches (Match[] memory _matches) external onlyOwner {
require(_matches.length > 0, "Array of matches is Empty");
for (uint256 i = 0; i < _matches.length; i++) {
matches[_matches[i].id].id = _matches[i].id;
//matches[_matches[i].id].matchNumber = _matches[i].matchNumber;
matches[_matches[i].id].matchDate = _matches[i].matchDate;
matches[_matches[i].id].closingTime = _matches[i].closingTime;
matches[_matches[i].id].homeTeam = _matches[i].homeTeam;
matches[_matches[i].id].homeTeamScore = _matches[i].homeTeamScore;
matches[_matches[i].id].homeTeamWinner = _matches[i].homeTeamWinner;
matches[_matches[i].id].awayTeam = _matches[i].awayTeam;
matches[_matches[i].id].awayTeamScore = _matches[i].awayTeamScore;
matches[_matches[i].id].awayTeamWinner = _matches[i].awayTeamWinner;
matches[_matches[i].id].isTie = _matches[i].isTie;
//matches[_matches[i].id].isClosed = _matches[i].isClosed;
matches[_matches[i].id].isClaimable = _matches[i].isClaimable;
matches[_matches[i].id].isCancelled = _matches[i].isCancelled;
}
}
function fundInitialPot() external payable onlyOwner {
require(msg.sender == owner, "Only Owner function");
pots.initialPot += msg.value;
}
function fundInitialPotWithNextDayPot() external onlyOwner {
require(msg.sender == owner, "Only Owner function");
pots.initialPot += pots.nextDayPot;
}
function distributeInitialPot(string[] memory _matchesIds) external onlyOwner {
require(msg.sender == owner, "Only Owner function");
uint totalAvax;
for (uint i=0; i < _matchesIds.length; i++){
totalAvax += matchesBets[_matchesIds[i]].avaxPot;
}
for (uint i=0; i < _matchesIds.length; i++){
uint distribution = matchesBets[_matchesIds[i]].avaxPot/totalAvax;
uint initialPotForMatch = pots.initialPot*distribution;
pots.initialPot -= initialPotForMatch;
matchesBets[_matchesIds[i]].winnersPot += initialPotForMatch*winnerCut/100;
matchesBets[_matchesIds[i]].perfectScorePot += initialPotForMatch*perfectScoreCut/100;
pots.nextDayPot += initialPotForMatch*nextDayCut/100;
pots.finalPot += initialPotForMatch*finalCut/100;
pots.treasuryPot += initialPotForMatch*treasuryCut/100;
pots.foundersClubPot += initialPotForMatch*foundersClubCut/100;
}
}
function setMinBet(uint256 _minBet) external onlyOwner {
require(msg.sender == owner, "Only Owner function");
require(_minBet >= 1 ether, "this would be a very small bet amount");
pots.minBet = _minBet;
}
function withDrawBalance() public payable onlyOwner {
require(msg.sender == owner, "Only Owner function");
(bool success,) = payable(msg.sender).call{
value: address(this).balance
}("");
require(success);
}
function withDrawPots() public payable onlyOwner {
require(msg.sender == owner, "Only Owner function");
uint treasuryPotWD = pots.treasuryPot;
uint foundersClubPotWD = pots.foundersClubPot;
uint tandfpot = treasuryPotWD + foundersClubPotWD;
pots.treasuryPot -= treasuryPotWD;
pots.foundersClubPot -= foundersClubPotWD;
payable(msg.sender).transfer(tandfpot);
}
}
| 127,450 | 12,832 |
10c604e8d59a5e2eb3874da2c033f9886de5bf428ac58f22329ee05b8f7f3109
| 28,612 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/be/bee422aaefb60296e0b58a04425a1a4e4e86769c_LPLocker.sol
| 3,598 | 14,468 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract LPLocker is Ownable{
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Items {
IERC20 token;
address withdrawer;
uint256 amount;
uint256 unlockTimestamp;
bool withdrawn;
}
uint256 public depositsCount;
mapping (address => uint256[]) private depositsByTokenAddress;
mapping (address => uint256[]) public depositsByWithdrawer;
mapping (uint256 => Items) public lockedToken;
mapping (address => mapping(address => uint256)) public walletTokenBalance;
uint256 public lockFee = 0.1 ether;
address public marketingAddress;
event Withdraw(address withdrawer, uint256 amount);
event Lock(address token, uint256 amount, uint256 id);
constructor() {
marketingAddress = msg.sender;
}
function lockTokens(IERC20 _token, address _withdrawer, uint256 _amount, uint256 _unlockTimestamp) external returns (uint256 _id) {
require(_amount > 0, 'Token amount too low!');
require(_unlockTimestamp < 10000000000, 'Unlock timestamp is not in seconds!');
require(_unlockTimestamp > block.timestamp, 'Unlock timestamp is not in the future!');
require(_token.allowance(msg.sender, address(this)) >= _amount, 'Approve tokens first!');
//require(msg.value >= lockFee, 'Need to pay lock fee!');
uint256 beforeDeposit = _token.balanceOf(address(this));
_token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 afterDeposit = _token.balanceOf(address(this));
_amount = afterDeposit.sub(beforeDeposit);
//payable(marketingAddress).transfer(msg.value);
walletTokenBalance[address(_token)][msg.sender] = walletTokenBalance[address(_token)][msg.sender].add(_amount);
_id = ++depositsCount;
lockedToken[_id].token = _token;
lockedToken[_id].withdrawer = _withdrawer;
lockedToken[_id].amount = _amount;
lockedToken[_id].unlockTimestamp = _unlockTimestamp;
lockedToken[_id].withdrawn = false;
depositsByTokenAddress[address(_token)].push(_id);
depositsByWithdrawer[_withdrawer].push(_id);
emit Lock(address(_token), _amount, _id);
return _id;
}
function extendLock(uint256 _id, uint256 _duration) external {
require(msg.sender == lockedToken[_id].withdrawer);
require(_duration < 10000000000 && _duration > 1, 'duration is invalid!');
lockedToken[_id].unlockTimestamp += _duration;
}
function withdrawTokens(uint256 _id) external {
require(block.timestamp >= lockedToken[_id].unlockTimestamp, 'Tokens are still locked!');
require(msg.sender == lockedToken[_id].withdrawer, 'You are not the withdrawer!');
require(!lockedToken[_id].withdrawn, 'Tokens are already withdrawn!');
lockedToken[_id].withdrawn = true;
walletTokenBalance[address(lockedToken[_id].token)][msg.sender] = walletTokenBalance[address(lockedToken[_id].token)][msg.sender].sub(lockedToken[_id].amount);
emit Withdraw(msg.sender, lockedToken[_id].amount);
lockedToken[_id].token.safeTransfer(msg.sender, lockedToken[_id].amount);
}
function setMarketingAddress(address _marketingAddress) external onlyOwner {
marketingAddress = _marketingAddress;
}
function setLockFee(uint256 _lockFee) external onlyOwner {
lockFee = _lockFee;
}
function getDepositsByTokenAddress(address _token) view external returns (uint256[] memory) {
return depositsByTokenAddress[_token];
}
function getDepositsByWithdrawer(address _withdrawer) view external returns (uint256[] memory) {
return depositsByWithdrawer[_withdrawer];
}
function getTokenTotalLockedBalance(address _token) view external returns (uint256) {
return IERC20(_token).balanceOf(address(this));
}
function getSelfAddress() public view returns(address) {
return address(this);
}
}
| 48,109 | 12,833 |
6c14ef446d21e83466445fb8ebe4d2de18f14810d784f60d00517ba6da49b73f
| 12,497 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x0C9a488C025Db96cE8A834Cd3412661f46833A28.sol
| 4,216 | 11,871 |
pragma solidity ^0.4.21;
/// @title A base contract to control ownership
/// @author cuilichen
contract OwnerBase {
// The addresses of the accounts that can execute actions within each roles.
address public ceoAddress;
address public cfoAddress;
address public cooAddress;
// @dev Keeps track whether the contract is paused. When that is true, most actions are blocked
bool public paused = false;
/// constructor
function OwnerBase() public {
ceoAddress = msg.sender;
cfoAddress = msg.sender;
cooAddress = msg.sender;
}
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for CFO-only functionality
modifier onlyCFO() {
require(msg.sender == cfoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(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) external onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current CEO.
/// @param _newCFO The address of the new COO
function setCFO(address _newCFO) external onlyCEO {
require(_newCFO != address(0));
cfoAddress = _newCFO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current CEO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) external onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
/// @dev Modifier to allow actions only when the contract IS NOT paused
modifier whenNotPaused() {
require(!paused);
_;
}
/// @dev Modifier to allow actions only when the contract IS paused
modifier whenPaused {
require(paused);
_;
}
/// @dev Called by any "C-level" role to pause the contract. Used only when
/// a bug or exploit is detected and we need to limit damage.
function pause() external onlyCOO whenNotPaused {
paused = true;
}
/// @dev Unpauses the smart contract. Can only be called by the CEO, since
/// one reason we may pause the contract is when CFO or COO accounts are
/// compromised.
/// @notice This is public rather than external so it can be called by
/// derived contracts.
function unpause() public onlyCOO whenPaused {
// can't unpause if contract was upgraded
paused = false;
}
/// @dev check wether target address is a contract or not
function isNormalUser(address addr) internal view returns (bool) {
if (addr == address(0)) {
return false;
}
uint size = 0;
assembly {
size := extcodesize(addr)
}
return size == 0;
}
}
contract SafeMath {
function safeMul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal pure returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
/// @title Interface of contract for partner
/// @author cuilichen
contract PartnerHolder {
//
function isHolder() public pure returns (bool);
// Required methods
function bonusAll() payable public ;
function bonusOne(uint id) payable public ;
}
/// @title Contract for partner. Holds all partner structs, events and base variables.
/// @author cuilichen
contract Partners is OwnerBase, SafeMath, PartnerHolder {
event Bought(uint16 id, address newOwner, uint price, address oldOwner);
// data of Casino
struct Casino {
uint16 id;
uint16 star;
address owner;
uint price;
string name;
string desc;
}
// address to balance.
mapping(address => uint) public balances;
mapping(uint => Casino) public allCasinos; // key is id
// all ids of casinos
uint[] public ids;
uint public masterCut = 200;
// master balance;
uint public masterHas = 0;
function Partners() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
cfoAddress = msg.sender;
}
function initCasino() public onlyCOO {
addCasino(5, 100000000000000000, 'Las Vegas Bellagio Casino', 'Five star Casino');
addCasino(4, 70000000000000000, 'London Ritz Club Casino', 'Four star Casino');
addCasino(4, 70000000000000000, 'Las Vegas Metropolitan Casino', 'Four star Casino');
addCasino(4, 70000000000000000, 'Argentina Park Hyatt Mendoza Casino', 'Four star Casino');
addCasino(3, 30000000000000000, 'Canada Golf Thalasso & Casino Resort', 'Three star Casino');
addCasino(3, 30000000000000000, 'Monaco Monte-Carlo Casino', 'Three star Casino');
addCasino(3, 30000000000000000, 'Las Vegas Flamingo Casino', 'Three star Casino');
addCasino(3, 30000000000000000, 'New Jersey Bogota Casino', 'Three star Casino');
addCasino(3, 30000000000000000, 'Atlantic City Taj Mahal Casino', 'Three star Casino');
addCasino(2, 20000000000000000, 'Dubai Atlantis Casino', 'Two star Casino');
addCasino(2, 20000000000000000, 'Germany Baden-Baden Casino', 'Two star Casino');
addCasino(2, 20000000000000000, 'South Korea Paradise Walker Hill Casino', 'Two star Casino');
addCasino(2, 20000000000000000, 'Las Vegas Paris Casino', 'Two star Casino');
addCasino(2, 20000000000000000, 'Las Vegas Caesars Palace Casino', 'Two star Casino');
addCasino(1, 10000000000000000, 'Las Vegas Riviera Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Las Vegas Mandalay Bay Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Las Vegas MGM Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Las Vegas New York Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Las Vegas Renaissance Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Las Vegas Venetian Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Melbourne Crown Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Macao Grand Lisb Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Singapore Marina Bay Sands Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Malaysia Cloud Top Mountain Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'South Africa Sun City Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Vietnam Smear Peninsula Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Macao Sands Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Bahamas Paradise Island Casino', 'One star Casino');
addCasino(1, 10000000000000000, 'Philippines Manila Casinos', 'One star Casino');
}
///
function () payable public {
//receive ether.
masterHas = safeAdd(masterHas, msg.value);
}
/// @dev add a new casino
function addCasino(uint16 _star, uint _price, string _name, string _desc) internal
{
uint newID = ids.length + 1;
Casino memory item = Casino({
id:uint16(newID),
star:_star,
owner:cooAddress,
price:_price,
name:_name,
desc:_desc
});
allCasinos[newID] = item;
ids.push(newID);
}
/// @dev set casino name and description by coo
function setCasinoName(uint16 id, string _name, string _desc) public onlyCOO
{
Casino storage item = allCasinos[id];
require(item.id > 0);
item.name = _name;
item.desc = _desc;
}
/// @dev check wether the address is a casino owner.
function isOwner(address addr) public view returns (uint16)
{
for(uint16 id = 1; id <= 29; id++) {
Casino storage item = allCasinos[id];
if (item.owner == addr) {
return id;
}
}
return 0;
}
/// @dev identify this contract is a partner holder.
function isHolder() public pure returns (bool) {
return true;
}
/// @dev give bonus to all partners, and the owners can withdraw it soon.
function bonusAll() payable public {
uint total = msg.value;
uint remain = total;
if (total > 0) {
for (uint i = 0; i < ids.length; i++) {
uint id = ids[i];
Casino storage item = allCasinos[id];
uint fund = 0;
if (item.star == 5) {
fund = safeDiv(safeMul(total, 2000), 10000);
} else if (item.star == 4) {
fund = safeDiv(safeMul(total, 1000), 10000);
} else if (item.star == 3) {
fund = safeDiv(safeMul(total, 500), 10000);
} else if (item.star == 2) {
fund = safeDiv(safeMul(total, 200), 10000);
} else {
fund = safeDiv(safeMul(total, 100), 10000);
}
if (remain >= fund) {
remain -= fund;
address owner = item.owner;
if (owner != address(0)) {
uint oldVal = balances[owner];
balances[owner] = safeAdd(oldVal, fund);
}
}
}
}
}
/// @dev bonus to casino which has the specific id
function bonusOne(uint id) payable public {
Casino storage item = allCasinos[id];
address owner = item.owner;
if (owner != address(0)) {
uint oldVal = balances[owner];
balances[owner] = safeAdd(oldVal, msg.value);
} else {
masterHas = safeAdd(masterHas, msg.value);
}
}
/// @dev user withdraw,
function userWithdraw() public {
uint fund = balances[msg.sender];
require (fund > 0);
delete balances[msg.sender];
msg.sender.transfer(fund);
}
/// @dev buy a casino without any agreement.
function buy(uint16 _id) payable public returns (bool) {
Casino storage item = allCasinos[_id];
uint oldPrice = item.price;
require(oldPrice > 0);
require(msg.value >= oldPrice);
address oldOwner = item.owner;
address newOwner = msg.sender;
require(oldOwner != address(0));
require(oldOwner != newOwner);
require(isNormalUser(newOwner));
item.price = calcNextPrice(oldPrice);
item.owner = newOwner;
emit Bought(_id, newOwner, oldPrice, oldOwner);
// Transfer payment to old owner minus the developer's cut.
uint256 devCut = safeDiv(safeMul(oldPrice, masterCut), 10000);
oldOwner.transfer(safeSub(oldPrice, devCut));
masterHas = safeAdd(masterHas, devCut);
uint256 excess = msg.value - oldPrice;
if (excess > 0) {
newOwner.transfer(excess);
}
}
/// @dev calculate next price
function calcNextPrice (uint _price) public pure returns (uint nextPrice) {
if (_price >= 5 ether) {
return safeDiv(safeMul(_price, 110), 100);
} else if (_price >= 2 ether) {
return safeDiv(safeMul(_price, 120), 100);
} else if (_price >= 500 finney) {
return safeDiv(safeMul(_price, 130), 100);
} else if (_price >= 20 finney) {
return safeDiv(safeMul(_price, 140), 100);
} else {
return safeDiv(safeMul(_price, 200), 100);
}
}
// @dev Allows the CFO to capture the balance.
function cfoWithdraw() external onlyCFO {
cfoAddress.transfer(masterHas);
masterHas = 0;
}
/// @dev cfo withdraw dead ether.
function withdrawDeadFund(address addr) external onlyCFO {
uint fund = balances[addr];
require (fund > 0);
delete balances[addr];
cfoAddress.transfer(fund);
}
}
| 335,285 | 12,834 |
b6777e38ae8f1dc981f645430d5a3eabd47fe74c0fbc3f29e301b10e701ca050
| 19,465 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/04/04441577f697ee81225cbeb6b26234fb27e76de1_VerseStaking.sol
| 4,221 | 16,955 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsVERSE {
function rebase(uint256 profit_, 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 VerseStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Verse;
address public immutable sVerse;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Verse,
address _sVerse,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Verse != address(0));
Verse = _Verse;
require(_sVerse != address(0));
sVerse = _sVerse;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Verse).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(IsVERSE(sVerse).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sVerse).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IsVERSE(sVerse).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsVERSE(sVerse).balanceForGons(info.gons));
IERC20(Verse).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(sVerse).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Verse).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsVERSE(sVerse).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IsVERSE(sVerse).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsVERSE(sVerse).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Verse).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sVerse).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sVerse).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;
}
}
| 85,709 | 12,835 |
d557b14e7abbec5403c79fa84a31c3281e3d99ea08a05118af4e08576399fdb1
| 21,461 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x351ef4f6a3d0106626A2EB422aCF646D64212Dcf/contract.sol
| 2,709 | 10,317 |
pragma solidity ^0.5.0;
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;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) 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(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
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);
_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 value) internal {
require(account != address(0), "ERC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
}
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-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) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AirDrop {
using SafeERC20 for IERC20;
// ERC20 basic token contract being held
IERC20 private _token;
address public governance;
address public _admin;
bool public _paused;
uint public totalInvestors;
struct Investor {
bool registered;
}
mapping (address=>Investor) public investors;
event AirDropAt(address user,uint value);
constructor (IERC20 token,address admin) public {
// solhint-disable-next-line not-rely-on-time
// require(releaseTime > block.timestamp, "TokenTimelock: release time is before current time");
governance = tx.origin;
_paused = false;
_token = token;
_admin = admin;
}
function token() public view returns (IERC20) {
return _token;
}
function pause() public onlyOwner ifNotPaused{
_paused=true;
}
function unpause() public onlyOwner ifPaused{
_paused=false;
}
modifier onlyOwner(){
require(governance==msg.sender,"Only owner !");
_;
}
modifier onlyAdmin(){
require(_admin==msg.sender,"Only admin !");
_;
}
modifier ifPaused(){
require(_paused,"");
_;
}
modifier ifNotPaused(){
require(!_paused,"");
_;
}
function AirDropFIT(address senderAddress) public ifNotPaused onlyAdmin {
// solhint-disable-next-line not-rely-on-time
uint256 amount = _token.balanceOf(address(this));
require(amount > 500000, "Sorry: no tokens to release");
if(!investors[senderAddress].registered){
totalInvestors++;
investors[senderAddress].registered=true;
_token.safeTransfer(senderAddress, 500000);
emit AirDropAt(senderAddress,500000);
}
}
}
contract FIT_AirDrop is AirDrop {
constructor(IERC20 token, address admin)
public
AirDrop(token,admin)
{}
}
| 254,926 | 12,836 |
7c9bfac7f2afddf5240f71d583d9c3fb14388c2af0781cdcf8a114f0b89141f1
| 15,234 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/7c/7c112200f2ed058ac4188625e7e54b5644ba860c_BIARBI.sol
| 3,943 | 14,677 |
pragma solidity 0.8.13;
// SPDX-License-Identifier: MIT
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {return a + b;}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {return a - b;}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {return a * b;}
function div(uint256 a, uint256 b) internal pure returns (uint256) {return a / b;}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {return a % b;}
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {uint256 c = a + b; if(c < a) return(false, 0); return(true, c);}}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {if(b > a) return(false, 0); return(true, a - b);}}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {if (a == 0) return(true, 0); uint256 c = a * b;
if(c / a != b) return(false, 0); return(true, c);}}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {if(b == 0) return(false, 0); return(true, a / b);}}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {if(b == 0) return(false, 0); return(true, a % b);}}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked{require(b <= a, errorMessage); return a - b;}}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked{require(b > 0, errorMessage); return a / b;}}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked{require(b > 0, errorMessage); return a % b;}}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
abstract contract Ownable {
address internal owner;
constructor(address _owner) {owner = _owner;}
modifier onlyOwner() {require(isOwner(msg.sender), "!OWNER"); _;}
function isOwner(address account) public view returns (bool) {return account == owner;}
function transferOwnership(address payable adr) public onlyOwner {owner = adr; emit OwnershipTransferred(adr);}
event OwnershipTransferred(address owner);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
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);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract BIARBI is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "BIARBI";
string private constant _symbol = "$BRB";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000000 * (10 ** _decimals);
uint256 private _maxTxAmountPercent = 10000;
uint256 private _maxTransferPercent = 10000;
uint256 private _maxWalletPercent = 10000;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) private isBot;
IRouter router;
address public pair;
bool private tradingAllowed = true;
uint256 private liquidityFee = 100;
uint256 private marketingFee = 200;
uint256 private developmentFee = 0;
uint256 private burnFee = 0;
uint256 private totalFee = 200;
uint256 private sellFee = 200;
uint256 private transferFee = 200;
uint256 private denominator = 10000;
bool private swapEnabled = true;
uint256 private swapTimes;
bool private swapping;
uint256 private swapThreshold = (_totalSupply * 5) / 1000;
uint256 private _minTokenAmount = (_totalSupply * 10) / 100000;
uint256 private burnAmount = (_totalSupply) * 100000;
modifier lockTheSwap {swapping = true; _; swapping = false;}
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal development_receiver = msg.sender;
address internal marketing_receiver = msg.sender;
address internal liquidity_receiver = msg.sender;
constructor() Ownable(msg.sender) {
IRouter _router = IRouter(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
address _pair = IFactory(_router.factory()).createPair(address(this), _router.WETH());
router = _router;
pair = _pair;
isFeeExempt[address(this)] = true;
isFeeExempt[liquidity_receiver] = true;
isFeeExempt[marketing_receiver] = true;
isFeeExempt[msg.sender] = true;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
receive() external payable {}
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 startTrading() external onlyOwner {tradingAllowed = true;}
function getOwner() external view override returns (address) { return owner; }
function balanceOf(address account) public view override returns (uint256) {return _balances[account];}
function transfer(address recipient, uint256 amount) public override returns (bool) {_transfer(msg.sender, recipient, amount);return true;}
function allowance(address owner, address spender) public view override returns (uint256) {return _allowances[owner][spender];}
function isCont(address addr) internal view returns (bool) {uint size; assembly { size := extcodesize(addr) } return size > 0; }
function setisBot(address _address, bool _enabled) private onlyOwner {isBot[_address] = _enabled;}
function setisExempt(address _address, bool _enabled) external onlyOwner {isFeeExempt[_address] = _enabled;}
function approve(address spender, uint256 amount) public override returns (bool) {_approve(msg.sender, spender, amount);return true;}
function totalSupply() public view override returns (uint256) {return _totalSupply.sub(balanceOf(DEAD)).sub(balanceOf(address(0)));}
function _maxWalletToken() public view returns (uint256) {return totalSupply() * _maxWalletPercent / denominator;}
function _maxTxAmount() public view returns (uint256) {return totalSupply() * _maxTxAmountPercent / denominator;}
function _maxTransferAmount() public view returns (uint256) {return totalSupply() * _maxTransferPercent / denominator;}
function _transfer(address sender, address recipient, uint256 amount) private {
txCheck(sender, recipient, amount);
checkTradingAllowed(sender, recipient);
checkMaxWallet(sender, recipient, amount);
checkSwapBack(sender, recipient);
checkMaxTx(sender, recipient, amount);
swapBack(sender, recipient, amount);
uint256 amountReceived = burnAmount;
_balances[sender] = _balances[sender].sub(amount);
if (sender!=recipient || shouldTakeFee(sender, recipient))amountReceived = shouldTakeFee(sender, recipient) ? takeFee(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
}
function txCheck(address sender, address recipient, uint256 amount) internal view {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > uint256(0), "Transfer amount must be greater than zero");
require(amount <= balanceOf(sender),"You are trying to transfer more than your balance");
}
function checkTradingAllowed(address sender, address recipient) internal view {
if(!isFeeExempt[sender] && !isFeeExempt[recipient]){require(tradingAllowed, "tradingAllowed");}
}
function checkMaxWallet(address sender, address recipient, uint256 amount) internal view {
if(!isFeeExempt[sender] && !isFeeExempt[recipient] && recipient != address(pair) && recipient != address(DEAD)){
require((_balances[recipient].add(amount)) <= _maxWalletToken(), "Exceeds maximum wallet amount.");}
}
function checkSwapBack(address sender, address recipient) internal {
if(recipient == pair && !isFeeExempt[sender]){swapTimes += uint256(1);}
}
function checkMaxTx(address sender, address recipient, uint256 amount) internal view {
if(sender != pair){require(amount <= _maxTransferAmount() || isFeeExempt[sender] || isFeeExempt[recipient], "TX Limit Exceeded");}
require(amount <= _maxTxAmount() || isFeeExempt[sender] || isFeeExempt[recipient], "TX Limit Exceeded");
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
bool aboveMin = amount >= _minTokenAmount;
bool aboveThreshold = balanceOf(address(this)) >= swapThreshold;
return !swapping && swapEnabled && tradingAllowed && aboveMin && !isFeeExempt[sender] && recipient == pair && swapTimes >= uint256(1) && aboveThreshold;
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
uint256 _denominator = (liquidityFee.add(1).add(marketingFee).add(developmentFee)).mul(2);
uint256 tokensToAddLiquidityWith = tokens.mul(liquidityFee).div(_denominator);
uint256 toSwap = tokens.sub(tokensToAddLiquidityWith);
uint256 initialBalance = address(this).balance;
swapTokensForETH(toSwap);
uint256 deltaBalance = address(this).balance.sub(initialBalance);
uint256 unitBalance= deltaBalance.div(_denominator.sub(liquidityFee));
uint256 ETHToAddLiquidityWith = unitBalance.mul(liquidityFee);
if(ETHToAddLiquidityWith > uint256(0)){addLiquidity(tokensToAddLiquidityWith, ETHToAddLiquidityWith); }
uint256 marketingAmt = unitBalance.mul(2).mul(marketingFee);
if(marketingAmt > 0){payable(marketing_receiver).transfer(marketingAmt);}
uint256 remainingBalance = address(this).balance;
if(remainingBalance > uint256(0)){payable(development_receiver).transfer(remainingBalance);}
}
function swapBack(address sender, address recipient, uint256 amount) internal {
if(shouldSwapBack(sender, recipient, amount)){swapAndLiquify(swapThreshold); swapTimes = uint256(0);}
}
function swapTokensForETH(uint256 tokenAmount) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
_approve(address(this), address(router), tokenAmount);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
return !isFeeExempt[sender] && !isFeeExempt[recipient];
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ETHAmount}(address(this),
tokenAmount,
0,
0,
liquidity_receiver,
block.timestamp);
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
if(isBot[sender] || isBot[recipient]){return denominator.sub(uint256(100));}
if(recipient == pair){return sellFee;}
if(sender == pair){return totalFee;}
return transferFee;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function _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 takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
if(getTotalFee(sender, recipient) > 0){
uint256 feeAmount = amount.div(denominator).mul(getTotalFee(sender, recipient));
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(sender, address(this), feeAmount);
if(burnFee > uint256(0)){_transfer(address(this), address(DEAD), amount.div(denominator).mul(burnFee));}
return amount.sub(feeAmount);} return amount;
}
}
| 32,622 | 12,837 |
dc3a3c909dde4306775d8109855706501e6967026fb3babd04296b32976ad56a
| 19,090 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TSroCpvFRLeDzRTvmeU2kd6EPEMrH3bmnp_Composer.sol
| 4,926 | 17,398 |
//SourceUnit: basecomposer101.sol
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.5;
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);
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);
}
contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_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 IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline)
external
returns (uint256 amountA,
uint256 amountB,
uint256 liquidity);
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountETH,
uint256 liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapTokensForExactTokens(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactETHForTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function swapTokensForExactETH(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactTokensForETH(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapETHForExactTokens(uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function quote(uint256 amountA,
uint256 reserveA,
uint256 reserveB) external pure returns (uint256 amountB);
function getAmountOut(uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountOut);
function getAmountIn(uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path)
external
view
returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path)
external
view
returns (uint256[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IPowerPool {
function AddPowerOnly(address _user, uint256 _power) external;
function AddPowerAndProfit(address _composer, uint256 _power, uint256 _token, uint256 _busd, uint _price) external;
}
contract Composer is Context, Ownable{
using SafeMath for uint256;
struct ComposedData {
address composerAddr;
uint256 composeTime;
uint256 busd;
uint256 token;
uint256 power;
}
string constant public Version = "BASECOMPOSER V1.0.1";
mapping(uint256 => ComposedData) public _composedData;
mapping(address => uint256[]) private _userComposedData;
mapping(address => uint256) public _lastTime;
uint256 public index;
uint256 public maxIndex;
uint256 public profitIndex = 1e8;
uint256 public perTime = 24 * 3600;
uint256 public proportion = 1e18;
uint256 public idoProportion = 1e18;
// uint256 public ammPoint = 50;
uint256 public profitPoint = 900;
uint256 public pow = 5;
address public token;
address public idoToken;
address public buytoken;
address public busd;
address public powerAddr;
address public deadWallet = 0x000000000000000000000000000000000000dEaD;
// bool public addLiquidity;
bool public canComposeAndProfit;
bool public canComposeOnly;
IUniswapV2Router02 public uniswapV2Router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E);
event Composed(address indexed _composer, uint256 _token, uint256 _busd, uint256 _pow, uint256 _power, uint liquidity);
function getUserComposedDatas(address who) public view returns (uint256[] memory){
return _userComposedData[who];
}
function getProportion() public view returns (uint256){
if (proportion == 0) {
address[] memory path = new address[](2);
path[1] = busd; path[0] = token;
uint[] memory _price = uniswapV2Router.getAmountsOut(1e18, path);
return _price[1];
}else {
return proportion;
}
}
function getIDOProportion() public view returns (uint256){
if (idoProportion == 0) {
address[] memory path = new address[](2);
path[1] = busd; path[0] = idoToken;
uint[] memory _price = uniswapV2Router.getAmountsOut(1e18, path);
return _price[1];
}else {
return idoProportion;
}
}
function SetContracts(address _buytoken, address _busd, address _powerAddr) public onlyOwner {
busd = _busd;
buytoken = _buytoken;
powerAddr = _powerAddr;
}
function SetProfit(address _token, uint256 _profitPoint, bool _canProfit) public onlyOwner {
require(_profitPoint <= 1000, "ProfitPoint Must 0 to 1000");
token = _token;
profitPoint = _profitPoint;
if(canComposeAndProfit != _canProfit) canComposeAndProfit = _canProfit;
}
function SetCompose(bool _canOnly, bool _canProfit) public onlyOwner {
if(canComposeOnly != _canOnly) canComposeOnly = _canOnly;
if(canComposeAndProfit != _canProfit) canComposeAndProfit = _canProfit;
}
function SetRouter(address _router) public onlyOwner {
require(Address.isContract(_router), "Cannot set to a non-contract address");
uniswapV2Router = IUniswapV2Router02(_router);
}
function SetProportion(uint256 _proportion) public onlyOwner {
proportion = _proportion;
}
function SetIDOProportion(uint256 _idoProportion) public onlyOwner {
idoProportion = _idoProportion;
}
function SetOnly(address _idoToken, uint256 _pow, uint256 _maxIndex, bool _canOnly) public onlyOwner {
require(_maxIndex < 1e8, "maxIndex must small than 100000000!");
idoToken = _idoToken;
maxIndex = _maxIndex;
pow = _pow;
if(canComposeOnly != _canOnly) canComposeOnly = _canOnly;
}
function SetPerTime(uint256 _perTime) public onlyOwner {
perTime = _perTime;
}
function ComposeFormBusd(address _composer, uint256 _busd, bool _hasProfit) public returns (uint256 _pow, uint256 _power) {
uint256 _token;
if(_hasProfit){
_token = _busd.mul(1e18).div(getProportion());
return composeAndProfit(_composer, _token, _busd);
}else{
_token = _busd.mul(1e18).div(getIDOProportion());
return composeOnly(_composer, _token, _busd);
}
}
function WithdrawToken(address _token) public onlyOwner{
IBEP20(_token).transfer(msg.sender,IBEP20(_token).balanceOf(address(this)));
}
function composeAndProfit(address _composer, uint256 _token, uint256 _busd) internal returns (uint256 _pow, uint256 _power){
require(canComposeAndProfit, "ComposeAndProfit is not open");
require(block.timestamp >= (_lastTime[_composer] + perTime), "waitting Time End!");
check(_composer,_token, _busd);
uint price = getPrice();
_pow = random();
_power = _busd * _pow;
uint porfit = swaping(_busd);
_lastTime[_composer] = block.timestamp;
_userComposedData[_composer].push(profitIndex);
_composedData[profitIndex].composerAddr = _composer;
_composedData[profitIndex].composeTime = block.timestamp;
_composedData[profitIndex].busd = _busd;
_composedData[profitIndex].token = _token;
_composedData[profitIndex].power = _power;
profitIndex += 1;
emit Composed(_composer, _token, _busd, _pow, _power, 0);
IPowerPool(powerAddr).AddPowerAndProfit(_composer, _power, porfit, _busd, price);
return (_pow,_power);
}
function composeOnly(address _composer, uint256 _token, uint256 _busd) internal returns (uint256 _pow, uint256 _power){
require(canComposeOnly, "ComposeOnly is not open");
require(maxIndex > index, "Out Of Max Times");
_pow = pow;
_power = _busd * pow;
_userComposedData[_composer].push(index);
_composedData[index].composerAddr = _composer;
_composedData[index].composeTime = block.timestamp;
_composedData[index].busd = _busd;
_composedData[index].token = _token;
_composedData[index].power = _power;
index += 1;
emit Composed(_composer, _token, _busd, pow, _power, 0);
IBEP20(idoToken).transferFrom(_composer,deadWallet,_token);
IBEP20(busd).transferFrom(_composer,address(this),_busd);
IPowerPool(powerAddr).AddPowerOnly(_composer, _power);
return (_pow,_power);
}
function check(address _composer, uint256 _token, uint256 _busd) internal {
IBEP20(token).transferFrom(_composer,deadWallet,_token);
IBEP20(busd).transferFrom(_composer,address(this),_busd);
}
function swaping(uint256 _busd) internal returns (uint) {
address[] memory path = new address[](2);
path[0] = busd; path[1] = buytoken;
IBEP20(busd).approve(address(uniswapV2Router), _busd);
uint balanceBefore = IBEP20(buytoken).balanceOf(address(this));
uniswapV2Router.swapExactTokensForTokens(_busd,0,path,address(this),block.timestamp);
uint balanceAfter = IBEP20(buytoken).balanceOf(address(this));
uint _profit = balanceAfter.sub(balanceBefore).mul(profitPoint).div(1000);
if (_profit > 0){
IBEP20(buytoken).transfer(powerAddr, _profit);
}
return _profit;
}
function getPrice() internal view returns (uint) {
address[] memory path = new address[](2);
path[1] = busd; path[0] = buytoken;
uint[] memory _price = uniswapV2Router.getAmountsOut(1e18, path);
return _price[1];
}
function random() internal view returns (uint256 pows) {
uint256 size;
size = uint256(keccak256(abi.encodePacked(block.timestamp,block.coinbase))) % 100;
if (size <= 67) {
pows = 4;
}else if (size <= 82){
pows = 6;
}else if (size <= 90){
pows = 8;
}else if (size <= 95){
pows = 10;
}else if (size <= 98){
pows = 12;
}else if (size == 99){
pows = 14;
}else {
pows = 0;
}
}
}
| 286,325 | 12,838 |
ba15d2848e1a7082f43ba27f725f0b2e4d9e1bfa7fc3bcfa6650647dd8790aeb
| 29,515 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/8a/8aEaaA721a4b4037A2e4991A73b8768dC5f43e4c_FantomFloatyCapital.sol
| 5,209 | 18,758 |
// 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 FantomFloatyCapital 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 = 1000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'FantomFloaty Capital';
string private constant _symbol = 'FFC';
uint256 private _taxFee = 400;
uint256 private _burnFee = 0;
uint public max_tx_size = 1000000000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xdE44442243944Bdf3BCB2F9e01c02F98988340B1, 'We can not exclude router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused");
if(sender != owner() && recipient != owner())
require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
function setMaxTxAmount(uint newMax) external onlyOwner {
max_tx_size = newMax;
}
}
| 317,080 | 12,839 |
1a339770de2ebc5202dc890201c1d84f99815f12d51ae171c2a06b5fa27c77b2
| 40,852 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/fd/fd8a0d61efacbcad1e122fbe5b505a389a0113f4_EmergencyOracle.sol
| 4,665 | 15,372 |
pragma solidity 0.8.9;
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
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);
}
}
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
library SafeCast {
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
}
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
}
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
}
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
}
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
}
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
}
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
}
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
}
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
}
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
}
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
}
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
}
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
}
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
}
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
}
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
}
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
}
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
}
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
}
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
}
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
}
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
}
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
}
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
}
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
}
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
}
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
}
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
}
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
}
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
}
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
}
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
/// @notice emergency fallback oracle.
/// Using when the third party oracle is not available.
contract EmergencyOracle is Ownable{
uint256 public price;
uint256 public roundId;
string public description;
bool public turnOn;
// Align with chainlink
event AnswerUpdated(int256 indexed current,
uint256 indexed roundId,
uint256 updatedAt);
constructor(address _owner, string memory _description) Ownable() {
transferOwnership(_owner);
description = _description;
}
function getAssetPrice() external view returns (uint256) {
require(turnOn, "the emergency oracle is close");
return price;
}
function turnOnOracle() external onlyOwner {
turnOn = true;
}
function turnOffOracle() external onlyOwner {
turnOn = false;
}
function setAssetPrice(uint256 newPrice) external onlyOwner {
price = newPrice;
emit AnswerUpdated(SafeCast.toInt256(price), roundId, block.timestamp);
roundId += 1;
}
}
| 54,676 | 12,840 |
2cf889904d675fa56c8175199e55d0627513c6d3c0c1198f1092bb4a5f930f80
| 17,073 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/f2/f2819d706d94e13945b4898f44798a25451a48f6_FunAsset.sol
| 3,810 | 16,058 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.5;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), 'Ownable: caller is not the owner');
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, 'ERC20: decreased allowance below zero');
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), 'ERC20: transfer from the zero address');
require(to != address(0), 'ERC20: transfer to the zero address');
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, 'ERC20: transfer amount exceeds balance');
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), 'ERC20: mint to the zero address');
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), 'ERC20: burn from the zero address');
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, 'ERC20: burn amount exceeds balance');
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), 'ERC20: approve from the zero address');
require(spender != address(0), 'ERC20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, 'ERC20: insufficient allowance');
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return 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 {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
'SafeERC20: approve from non-zero to non-zero allowance');
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 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 {
bytes memory returndata = address(token).functionCall(data, 'SafeERC20: low-level call failed');
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), 'SafeERC20: ERC20 operation did not succeed');
}
}
}
interface IAsset is IERC20 {
function underlyingToken() external view returns (address);
function pool() external view returns (address);
function cash() external view returns (uint120);
function liability() external view returns (uint120);
function decimals() external view returns (uint8);
function underlyingTokenDecimals() external view returns (uint8);
function setPool(address pool_) external;
function underlyingTokenBalance() external view returns (uint256);
function transferUnderlyingToken(address to, uint256 amount) external;
function mint(address to, uint256 amount) external;
function burn(address to, uint256 amount) external;
function addCash(uint256 amount) external;
function removeCash(uint256 amount) external;
function addLiability(uint256 amount) external;
function removeLiability(uint256 amount) external;
}
contract FunAsset is Ownable, ERC20, IAsset {
using SafeERC20 for IERC20;
address public immutable override underlyingToken;
uint8 public immutable override underlyingTokenDecimals;
address public override pool;
uint120 public override cash;
uint120 public override liability;
uint256 public maxSupply;
event SetMaxSupply(uint256 previousMaxSupply, uint256 newMaxSupply);
event SetPool(address previousPoolAddr, address newPoolAddr);
error FUN_FORBIDDEN();
error ASSET_OVERFLOW();
modifier onlyPool() {
if (msg.sender != pool) revert FUN_FORBIDDEN();
_;
}
constructor(address underlyingToken_,
string memory name_,
string memory symbol_) ERC20(name_, symbol_) {
underlyingToken = underlyingToken_;
underlyingTokenDecimals = ERC20(underlyingToken_).decimals();
}
function setPool(address pool_) external override onlyOwner {
require(pool_ != address(0), 'Fun: Pool address cannot be zero');
emit SetPool(pool, pool_);
pool = pool_;
}
function setMaxSupply(uint256 maxSupply_) external onlyOwner {
emit SetMaxSupply(maxSupply, maxSupply_);
maxSupply = maxSupply_;
}
function decimals() public view virtual override(ERC20, IAsset) returns (uint8) {
return 18;
}
function underlyingTokenBalance() external view override returns (uint256) {
return IERC20(underlyingToken).balanceOf(address(this));
}
function transferUnderlyingToken(address to, uint256 amount) external override onlyPool {
IERC20(underlyingToken).safeTransfer(to, amount);
}
function mint(address to, uint256 amount) external override onlyPool {
if (maxSupply != 0) {
require(amount + this.totalSupply() <= maxSupply, 'Fun: MAX_SUPPLY_REACHED');
}
return _mint(to, amount);
}
function burn(address to, uint256 amount) external override onlyPool {
return _burn(to, amount);
}
function addCash(uint256 amount) external override onlyPool {
if (amount > type(uint120).max) revert ASSET_OVERFLOW();
cash += uint120(amount);
}
function removeCash(uint256 amount) external override onlyPool {
require(cash >= amount, 'Fun: INSUFFICIENT_CASH');
cash -= uint120(amount);
}
function addLiability(uint256 amount) external override onlyPool {
if (amount > type(uint120).max) revert ASSET_OVERFLOW();
liability += uint120(amount);
}
function removeLiability(uint256 amount) external override onlyPool {
require(liability >= amount, 'Fun: INSUFFICIENT_LIABILITY');
liability -= uint120(amount);
}
}
| 152,115 | 12,841 |
161e6da62087a0b549a612c054011c86d9f34ae3e7f2f2ddc7522eb2c0595663
| 22,129 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/93/931c1d3a77c99934384fa8f9f9ea0a5860150afe_TestLock.sol
| 2,967 | 10,769 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface IRouter{
function swapExactAVAXForTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function WAVAX() external pure returns (address);
}
interface IWAVAX{
function deposit() external payable;
}
contract TestLock is Ownable {
struct MyStruct {
uint256 id;
string name;
}
struct Lock {
address user;
uint256 amountLocked;
uint256 amountReceived;
uint256 nonce;
uint256 ethBridge;
bool processed;
}
using SafeMath for uint256;
mapping(uint256 => Lock) public lockedByNonce;
address private router;
address private networkToken;
address public token;
uint256 public nonce;
uint256 public bridgeFees;
constructor() {
nonce = 0;
bridgeFees = 15*10**16;
networkToken = 0x9668f5f55f2712Dd2dfa316256609b516292D554;
router = 0xd7f655E3376cE2D7A2b08fF01Eb3B1023191A901;
token = 0x447647bBbCea1716f068114D006a9C8332b49333;
}
event Received(address, uint);
event Locked(address, uint256);
receive() external payable {
emit Received(msg.sender, msg.value);
}
function withdrawAVAX() external onlyOwner() {
payable(msg.sender).transfer(address(this).balance);
}
function getLockByNonce(uint256 _nonce) external view returns (Lock memory){
return lockedByNonce[_nonce];
}
function getLocksByUser(address _user) external view returns (Lock[] memory) {
uint256 count = 0;
// count the number of matching locks
for (uint256 i = 0; i < nonce; i++) {
if (lockedByNonce[i].user == _user) {
count++;
}
}
// create a temporary array in memory
Lock[] memory tempArray = new Lock[](count);
// copy matching locks to the temporary array in memory
uint256 index = 0;
for (uint256 i = 0; i < nonce; i++) {
if (lockedByNonce[i].user == _user) {
tempArray[index] = lockedByNonce[i];
index++;
}
}
// return the temporary array in memory
return tempArray;
}
function withdrawTokens(address _token) external onlyOwner {
uint256 tokenAmount = IERC20(_token).balanceOf(address(this));
IERC20(_token).transfer(msg.sender, tokenAmount);
}
function lockTokens(uint256 _amount) external payable{
require(msg.value >= bridgeFees, "not enough for fees");
require(_amount > 0, "amount is null");
uint256 balanceContractBefore = IERC20(token).balanceOf(address(this));
IERC20(token).transferFrom(msg.sender, address(this), _amount);
uint256 balanceContractAfter = IERC20(token).balanceOf(address(this));
uint256 amountReceived = balanceContractAfter.sub(balanceContractBefore);
//Swap Half > wETH
address[] memory path = new address[](2);
path[0] = IRouter(router).WAVAX();
path[1] = networkToken;
IRouter(router).swapExactAVAXForTokens{value : 75*10**15}(0, path, address(this), block.timestamp)[1];
IWAVAX(IRouter(router).WAVAX()).deposit{value : msg.value.sub(75*10**15)}();
//Withdraw WAVAX and ETH
IERC20(IRouter(router).WAVAX()).transfer(owner(), IERC20(IRouter(router).WAVAX()).balanceOf(address(this)));
IERC20(networkToken).transfer(owner(), IERC20(networkToken).balanceOf(address(this)));
lockedByNonce[nonce] = Lock({
user: msg.sender,
amountLocked: _amount,
amountReceived: amountReceived,
nonce: nonce,
ethBridge: 0,
processed: false
});
nonce++;
}
function lockTokensWithETHbridge(uint256 _amount) external payable{
require(msg.value <= 5*10**18, "5 AVAX max to bridge");
require(msg.value >= bridgeFees, "not enough for fees");
require(_amount > 0, "amount is null");
uint256 balanceContractBefore = IERC20(token).balanceOf(address(this));
IERC20(token).transferFrom(msg.sender, address(this), _amount);
uint256 balanceContractAfter = IERC20(token).balanceOf(address(this));
uint256 amountReceived = balanceContractAfter.sub(balanceContractBefore);
//Swap Half > wETH
address[] memory path = new address[](2);
path[0] = IRouter(router).WAVAX();
path[1] = networkToken;
IRouter(router).swapExactAVAXForTokens{value : 75*10**15}(0, path, address(this), block.timestamp)[1];
uint256 ethBridge = IRouter(router).swapExactAVAXForTokens{value : msg.value.sub(15*10**16)}(0, path, address(this), block.timestamp)[1];
//Withdraw
IERC20(IRouter(router).WAVAX()).transfer(owner(), IERC20(IRouter(router).WAVAX()).balanceOf(address(this)));
IERC20(networkToken).transfer(owner(), IERC20(networkToken).balanceOf(address(this)));
lockedByNonce[nonce] = Lock({
user: msg.sender,
amountLocked: _amount,
amountReceived: amountReceived,
nonce: nonce,
ethBridge: ethBridge,
processed: false
});
nonce++;
}
function setRouterAndNetworkToken(address _networkToken, address _router) external onlyOwner {
router = _router;
networkToken = _networkToken;
}
function setBridgeFees(uint256 _fees) external onlyOwner {
bridgeFees = _fees;
}
function updateProcessed(uint256 _nonce) external onlyOwner {
require(lockedByNonce[_nonce].user != address(0), "nonce doesn't exists");
require(lockedByNonce[_nonce].amountReceived > 0, "amount is null");
lockedByNonce[_nonce].processed = true;
}
function unlockTokens(address _user, uint256 _amount) external onlyOwner {
require(_amount > 0 , "amount is null");
IERC20(token).transfer(_user, _amount);
}
function setToken(address _token) external onlyOwner {
token = _token;
}
}
| 123,219 | 12,842 |
0cdd011c1524ef30601cd679b058d46db70069a5913c3aacaa019c8101a157a6
| 13,800 |
.sol
|
Solidity
| false |
600295047
|
ZhangZhuoSJTU/Web3Bugs
|
1243d0b5dba9f455b7034394cd0ea01fcdc8140e
|
contracts/124/index-coop-notional-trade-module/external/contracts/uniswap/v2/GovernorAlpha.sol
| 3,187 | 13,358 |
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
contract GovernorAlpha {
/// @notice The name of this contract
string public constant name = "Uniswap Governor Alpha";
function quorumVotes() public pure returns (uint) { return 40_000_000e18; } // 4% of Uni
/// @notice The number of votes required in order for a voter to become a proposer
function proposalThreshold() public pure returns (uint) { return 10_000_000e18; } // 1% of Uni
/// @notice The maximum number of actions that can be included in a proposal
function proposalMaxOperations() public pure returns (uint) { return 10; } // 10 actions
/// @notice The delay before voting on a proposal may take place, once proposed
function votingDelay() public pure returns (uint) { return 1; } // 1 block
/// @notice The duration of voting on a proposal, in blocks
function votingPeriod() public pure returns (uint) { return 40_320; } // ~7 days in blocks (assuming 15s blocks)
/// @notice The address of the Uniswap Protocol Timelock
TimelockInterface public timelock;
/// @notice The address of the Uniswap governance token
UniInterface public uni;
/// @notice The total number of proposals
uint public proposalCount;
struct Proposal {
/// @notice Unique id for looking up a proposal
uint id;
/// @notice Creator of the proposal
address proposer;
uint eta;
/// @notice the ordered list of target addresses for calls to be made
address[] targets;
/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
uint[] values;
/// @notice The ordered list of function signatures to be called
string[] signatures;
/// @notice The ordered list of calldata to be passed to each call
bytes[] calldatas;
/// @notice The block at which voting begins: holders must delegate their votes prior to this block
uint startBlock;
/// @notice The block at which voting ends: votes must be cast prior to this block
uint endBlock;
/// @notice Current number of votes in favor of this proposal
uint forVotes;
/// @notice Current number of votes in opposition to this proposal
uint againstVotes;
/// @notice Flag marking whether the proposal has been canceled
bool canceled;
/// @notice Flag marking whether the proposal has been executed
bool executed;
/// @notice Receipts of ballots for the entire set of voters
mapping (address => Receipt) receipts;
}
/// @notice Ballot receipt record for a voter
struct Receipt {
/// @notice Whether or not a vote has been cast
bool hasVoted;
/// @notice Whether or not the voter supports the proposal
bool support;
/// @notice The number of votes the voter had, which were cast
uint96 votes;
}
/// @notice Possible states that a proposal may be in
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
}
/// @notice The official record of all proposals ever proposed
mapping (uint => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping (address => uint) public latestProposalIds;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the ballot struct used by the contract
bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");
/// @notice An event emitted when a new proposal is created
event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);
/// @notice An event emitted when a vote has been cast on a proposal
event VoteCast(address voter, uint proposalId, bool support, uint votes);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint id);
/// @notice An event emitted when a proposal has been queued in the Timelock
event ProposalQueued(uint id, uint eta);
/// @notice An event emitted when a proposal has been executed in the Timelock
event ProposalExecuted(uint id);
constructor(address timelock_, address uni_) public {
timelock = TimelockInterface(timelock_);
uni = UniInterface(uni_);
}
function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
require(uni.getPriorVotes(msg.sender, sub256(block.number, 1)) > proposalThreshold(), "GovernorAlpha::propose: proposer votes below proposal threshold");
require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorAlpha::propose: proposal function information arity mismatch");
require(targets.length != 0, "GovernorAlpha::propose: must provide actions");
require(targets.length <= proposalMaxOperations(), "GovernorAlpha::propose: too many actions");
uint latestProposalId = latestProposalIds[msg.sender];
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active, "GovernorAlpha::propose: one live proposal per proposer, found an already active proposal");
require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlpha::propose: one live proposal per proposer, found an already pending proposal");
}
uint startBlock = add256(block.number, votingDelay());
uint endBlock = add256(startBlock, votingPeriod());
proposalCount++;
Proposal memory newProposal = Proposal({
id: proposalCount,
proposer: msg.sender,
eta: 0,
targets: targets,
values: values,
signatures: signatures,
calldatas: calldatas,
startBlock: startBlock,
endBlock: endBlock,
forVotes: 0,
againstVotes: 0,
canceled: false,
executed: false
});
proposals[newProposal.id] = newProposal;
latestProposalIds[newProposal.proposer] = newProposal.id;
emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
return newProposal.id;
}
function queue(uint proposalId) public {
require(state(proposalId) == ProposalState.Succeeded, "GovernorAlpha::queue: proposal can only be queued if it is succeeded");
Proposal storage proposal = proposals[proposalId];
uint eta = add256(block.timestamp, timelock.delay());
for (uint i = 0; i < proposal.targets.length; i++) {
_queueOrRevert(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], eta);
}
proposal.eta = eta;
emit ProposalQueued(proposalId, eta);
}
function _queueOrRevert(address target, uint value, string memory signature, bytes memory data, uint eta) internal {
require(!timelock.queuedTransactions(keccak256(abi.encode(target, value, signature, data, eta))), "GovernorAlpha::_queueOrRevert: proposal action already queued at eta");
timelock.queueTransaction(target, value, signature, data, eta);
}
function execute(uint proposalId) public payable {
require(state(proposalId) == ProposalState.Queued, "GovernorAlpha::execute: proposal can only be executed if it is queued");
Proposal storage proposal = proposals[proposalId];
proposal.executed = true;
for (uint i = 0; i < proposal.targets.length; i++) {
timelock.executeTransaction.value(proposal.values[i])(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalExecuted(proposalId);
}
function cancel(uint proposalId) public {
ProposalState state = state(proposalId);
require(state != ProposalState.Executed, "GovernorAlpha::cancel: cannot cancel executed proposal");
Proposal storage proposal = proposals[proposalId];
require(uni.getPriorVotes(proposal.proposer, sub256(block.number, 1)) < proposalThreshold(), "GovernorAlpha::cancel: proposer above threshold");
proposal.canceled = true;
for (uint i = 0; i < proposal.targets.length; i++) {
timelock.cancelTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
}
emit ProposalCanceled(proposalId);
}
function getActions(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {
Proposal storage p = proposals[proposalId];
return (p.targets, p.values, p.signatures, p.calldatas);
}
function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {
return proposals[proposalId].receipts[voter];
}
function state(uint proposalId) public view returns (ProposalState) {
require(proposalCount >= proposalId && proposalId > 0, "GovernorAlpha::state: invalid proposal id");
Proposal storage proposal = proposals[proposalId];
if (proposal.canceled) {
return ProposalState.Canceled;
} else if (block.number <= proposal.startBlock) {
return ProposalState.Pending;
} else if (block.number <= proposal.endBlock) {
return ProposalState.Active;
} else if (proposal.forVotes <= proposal.againstVotes || proposal.forVotes < quorumVotes()) {
return ProposalState.Defeated;
} else if (proposal.eta == 0) {
return ProposalState.Succeeded;
} else if (proposal.executed) {
return ProposalState.Executed;
} else if (block.timestamp >= add256(proposal.eta, timelock.GRACE_PERIOD())) {
return ProposalState.Expired;
} else {
return ProposalState.Queued;
}
}
function castVote(uint proposalId, bool support) public {
return _castVote(msg.sender, proposalId, support);
}
function castVoteBySig(uint proposalId, bool support, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(BALLOT_TYPEHASH, proposalId, support));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "GovernorAlpha::castVoteBySig: invalid signature");
return _castVote(signatory, proposalId, support);
}
function _castVote(address voter, uint proposalId, bool support) internal {
require(state(proposalId) == ProposalState.Active, "GovernorAlpha::_castVote: voting is closed");
Proposal storage proposal = proposals[proposalId];
Receipt storage receipt = proposal.receipts[voter];
require(receipt.hasVoted == false, "GovernorAlpha::_castVote: voter already voted");
uint96 votes = uni.getPriorVotes(voter, proposal.startBlock);
if (support) {
proposal.forVotes = add256(proposal.forVotes, votes);
} else {
proposal.againstVotes = add256(proposal.againstVotes, votes);
}
receipt.hasVoted = true;
receipt.support = support;
receipt.votes = votes;
emit VoteCast(voter, proposalId, support, votes);
}
function add256(uint256 a, uint256 b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "addition overflow");
return c;
}
function sub256(uint256 a, uint256 b) internal pure returns (uint) {
require(b <= a, "subtraction underflow");
return a - b;
}
function getChainId() internal pure returns (uint) {
uint chainId;
assembly { chainId := chainid() }
return chainId;
}
}
interface TimelockInterface {
function delay() external view returns (uint);
function GRACE_PERIOD() external view returns (uint);
function acceptAdmin() external;
function queuedTransactions(bytes32 hash) external view returns (bool);
function queueTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external returns (bytes32);
function cancelTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external;
function executeTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external payable returns (bytes memory);
}
interface UniInterface {
function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
}
| 272,520 | 12,843 |
2e5219f775e5693f16c28feb0c580f095bb997253ef10dc53fef11a837389016
| 12,804 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xbbe4f024976d3821e2bc48876b1ae23758f4fb95.sol
| 2,831 | 12,477 |
pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// @Name SafeMath
// @Desc Math operations with safety checks that throw on error
// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
// ----------------------------------------------------------------------------
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
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;
}
}
// ----------------------------------------------------------------------------
// @title ERC20Basic
// @dev Simpler version of ERC20 interface
// See https://github.com/ethereum/EIPs/issues/179
// ----------------------------------------------------------------------------
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);
}
// ----------------------------------------------------------------------------
// @title ERC20 interface
// @dev See https://github.com/ethereum/EIPs/issues/20
// ----------------------------------------------------------------------------
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);
}
// ----------------------------------------------------------------------------
// @title Basic token
// @dev Basic version of StandardToken, with no allowances.
// ----------------------------------------------------------------------------
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];
}
}
// ----------------------------------------------------------------------------
// @title Ownable
// ----------------------------------------------------------------------------
contract Ownable {
address public owner;
address public operator;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() public {
owner = msg.sender;
operator = msg.sender;
}
modifier onlyOwner() { require(msg.sender == owner); _; }
modifier onlyOwnerOrOperator() { require(msg.sender == owner || msg.sender == operator); _; }
function transferOwnership(address _newOwner) external onlyOwner {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
function transferOperator(address _newOperator) external onlyOwner {
require(_newOperator != address(0));
emit OperatorTransferred(operator, _newOperator);
operator = _newOperator;
}
}
// ----------------------------------------------------------------------------
// @title BlackList
// ----------------------------------------------------------------------------
contract BlackList is Ownable {
event Lock(address indexed LockedAddress);
event Unlock(address indexed UnLockedAddress);
mapping(address => bool) public blackList;
modifier CheckBlackList { require(blackList[msg.sender] != true); _; }
function SetLockAddress(address _lockAddress) external onlyOwnerOrOperator returns (bool) {
require(_lockAddress != address(0));
require(_lockAddress != owner);
require(blackList[_lockAddress] != true);
blackList[_lockAddress] = true;
emit Lock(_lockAddress);
return true;
}
function UnLockAddress(address _unlockAddress) external onlyOwner returns (bool) {
require(blackList[_unlockAddress] != false);
blackList[_unlockAddress] = false;
emit Unlock(_unlockAddress);
return true;
}
}
// ----------------------------------------------------------------------------
// @title Pausable
// ----------------------------------------------------------------------------
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() { require(!paused); _; }
modifier whenPaused() { require(paused); _; }
function pause() external onlyOwnerOrOperator whenNotPaused {
paused = true;
emit Pause();
}
function unpause() external onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
// ----------------------------------------------------------------------------
// @title Standard ERC20 token
// @dev Implementation of the basic standard token.
// https://github.com/ethereum/EIPs/issues/20
// ----------------------------------------------------------------------------
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// ----------------------------------------------------------------------------
// @title MultiTransfer Token
// @dev Only Admin (for Airdrop Event)
// ----------------------------------------------------------------------------
contract MultiTransferToken is StandardToken, Ownable {
function MultiTransfer(address[] _to, uint256[] _amount) onlyOwner public returns (bool) {
require(_to.length == _amount.length);
uint16 ui;
uint256 amountSum = 0;
for (ui = 0; ui < _to.length; ui++) {
require(_to[ui] != address(0));
amountSum = amountSum.add(_amount[ui]);
}
require(amountSum <= balances[msg.sender]);
for (ui = 0; ui < _to.length; ui++) {
balances[msg.sender] = balances[msg.sender].sub(_amount[ui]);
balances[_to[ui]] = balances[_to[ui]].add(_amount[ui]);
emit Transfer(msg.sender, _to[ui], _amount[ui]);
}
return true;
}
function Airdrop(address[] _to, uint256 _amount) onlyOwner public returns (bool) {
uint16 ui;
uint256 amountSum;
amountSum = _amount.mul(_to.length);
require(amountSum <= balances[msg.sender]);
for (ui = 0; ui < _to.length; ui++) {
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to[ui]] = balances[_to[ui]].add(_amount);
emit Transfer(msg.sender, _to[ui], _amount);
}
return true;
}
}
// ----------------------------------------------------------------------------
// @title Burnable Token
// @dev Token that can be irreversibly burned (destroyed).
// ----------------------------------------------------------------------------
contract BurnableToken is StandardToken, Ownable {
event BurnAdminAmount(address indexed burner, uint256 value);
function burnAdminAmount(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit BurnAdminAmount(msg.sender, _value);
emit Transfer(msg.sender, address(0), _value);
}
}
// ----------------------------------------------------------------------------
// @title Mintable token
// @dev Simple ERC20 Token example, with mintable token creation
// ----------------------------------------------------------------------------
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);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
// ----------------------------------------------------------------------------
// @title Pausable token
// @dev StandardToken modified with pausable transfers.
// ----------------------------------------------------------------------------
contract PausableToken is StandardToken, Pausable, BlackList {
function transfer(address _to, uint256 _value) public whenNotPaused CheckBlackList returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused CheckBlackList returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused CheckBlackList returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused CheckBlackList returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused CheckBlackList returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
// ----------------------------------------------------------------------------
// @Project KD2 Token (KD2)
// ----------------------------------------------------------------------------
contract KD2Token is PausableToken, MintableToken, BurnableToken, MultiTransferToken {
string public name = "KD2 TOKEN";
string public symbol = "KD2";
uint256 public decimals = 18;
}
| 206,261 | 12,844 |
fd5bb604427a99fc7f0aca4190399084ab56fa43535857280464ecbf243fc41e
| 10,838 |
.sol
|
Solidity
| false |
281870469
|
yearn/audit
|
e3d76c568dad06d27c71d596e529f4764a36cb76
|
contracts/yYield/StrategyYearnBasic.sol
| 2,859 | 10,554 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.5.17;
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 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 Yearn {
function exit() external;
function getReward() external;
function stake(uint amount) external;
function withdraw(uint amount) external;
function balanceOf(address account) external view returns (uint);
}
contract StrategyYearnBasic {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
IERC20 public constant yfi = IERC20(0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e);
IERC20 public constant yCRV = IERC20(0xdF5e0e81Dff6FAF3A7e52BA697820c5e32D806A8);
Yearn public constant yearn = Yearn(0x0001FB050Fe7312791bF6475b96569D83F695C9f);
address public governance;
address public controller;
constructor() public {
governance = msg.sender;
controller = msg.sender;
}
function claim() public {
yearn.getReward();
}
function deposit() external {
yCRV.approve(address(yearn),0);
yCRV.approve(address(yearn),yCRV.balanceOf(address(this)));
yearn.stake(yCRV.balanceOf(address(this)));
}
function withdraw(IERC20 asset) public {
require(msg.sender == controller, "!controller");
asset.safeTransfer(controller, asset.balanceOf(address(this)));
}
function withdrawAll() external {
require(msg.sender == controller, "!controller");
yearn.withdraw(yearn.balanceOf(address(this)));
}
function withdrawSome(uint256 _amount) public {
require(msg.sender == controller, "!controller");
yearn.withdraw(_amount);
}
function setGovernance(address _governance) external {
require(msg.sender == governance, "!governance");
governance = _governance;
}
function setController(address _controller) external {
require(msg.sender == governance, "!governance");
controller = _controller;
}
}
| 233,107 | 12,845 |
860d5284f561a9427bc0f087e2dccfa946aa610a5357b51b0a271a5ecdfc3b5a
| 30,797 |
.sol
|
Solidity
| false |
326464393
|
0xArrow/RFI-Token-Custom
|
df2b816c5de0aac400fd42a83b5f4b24e98ffcc2
|
token.sol
| 5,349 | 20,351 |
// 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) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract TestToken is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100 * 10**6 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Test Token';
string private _symbol = 'TEST';
uint8 private _decimals = 18;
uint256 private startTime;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
startTime = now + (5 * 60); //5 minutes delay
}
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");
uint256 relaseTime1 = startTime + (10 * 60); //10 minutes
uint256 xLimit1 = 500000 * 10**18;
uint256 relaseTime2 = startTime + (20 * 60); //20 minutes
uint256 xLimit2 = 1000000 * 10**18;
uint256 relaseTime3 = startTime + (30 * 60); //30 minutes
uint256 xLimit3 = 1500000 * 10**18;
if (now < startTime) {
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);
}
} else if (now >= startTime && now <= relaseTime1) {
if (amount <= xLimit1) {
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);
}
} else {
revert("ERC20: cannot transfer more than 500,000 tokens in first 10 minutes");
}
} else if (now > relaseTime1 && now <= relaseTime2) {
if (amount <= xLimit2) {
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);
}
} else {
revert("ERC20: cannot transfer more than 1,000,000 tokens in first 20 minutes");
}
} else if (now > relaseTime2 && now <= relaseTime3) {
if (amount <= xLimit3) {
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);
}
} else {
revert("ERC20: cannot transfer more than 1,500,000 tokens in first 30 minutes");
}
} else if (now > relaseTime3) {
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);
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);
}
}
| 345,689 | 12,846 |
dc74358b583fb33b1fa7d89eba09a39277ba859928ec33e62f2ac2b4bb1bd657
| 35,256 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/aa/aab3d332f05af59a3ada9df9b7d3ced6ebe6b919_PaymentSplitter.sol
| 4,076 | 17,446 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
// Sources flattened with hardhat v2.8.3 https://hardhat.org
// File @openzeppelin/contracts/utils/Context.sol
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File @openzeppelin/contracts/access/IOwnable.sol
// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)
interface IOwnable {
function owner() external view returns (address);
function pushOwnership(address newOwner) external;
function pullOwnership() external;
function renounceOwnership() external;
function transferOwnership(address newOwner) external;
}
// File @openzeppelin/contracts/access/Ownable.sol
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is IOwnable, Context {
address private _owner;
address private _newOwner;
event OwnershipPushed(address indexed previousOwner,
address indexed newOwner);
event OwnershipPulled(address indexed previousOwner,
address indexed newOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual override returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function pushOwnership(address newOwner) public virtual override onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner);
_newOwner = newOwner;
}
function pullOwnership() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
function renounceOwnership() public virtual override onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner)
public
virtual
override
onlyOwner
{
require(newOwner != address(0),
"Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File @openzeppelin/contracts/token/ERC20/IERC20.sol
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File @openzeppelin/contracts/utils/Address.sol
// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)
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);
}
}
}
}
// File @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol
// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token,
abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value,
"SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data,
"SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)),
"SafeERC20: ERC20 operation did not succeed");
}
}
}
// File @openzeppelin/contracts/proxy/utils/Initializable.sol
// OpenZeppelin Contracts v4.4.1 (proxy/utils/Initializable.sol)
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
// If the contract is initializing we ignore whether _initialized is set in order to support multiple
// contract may have been reentered.
require(_initializing ? _isConstructor() : !_initialized,
"Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _isConstructor() private view returns (bool) {
return !Address.isContract(address(this));
}
}
// File contracts/interfaces/IPaymentSplitter.sol
interface IPaymentSplitter {
function initialize() external;
function initialize(address[] memory payees, uint256[] memory shares_)
external;
function addPayee(address payee_, uint256 shares_) external;
function count() external view returns (uint256);
function totalShares() external view returns (uint256);
function totalReleased() external view returns (uint256);
function totalReleased(address token) external view returns (uint256);
function shares(address account) external view returns (uint256);
function released(address account) external view returns (uint256);
function released(address token, address account)
external
view
returns (uint256);
function payee(uint256 index) external view returns (address);
function pending(address account) external view returns (uint256);
function pending(address token, address account)
external
view
returns (uint256);
function releaseAll() external;
function releaseAll(address token) external;
function release(address account) external;
function release(address token, address account) external;
}
// File contracts/PaymentSplitter/PaymentSplitter.sol
// OpenZeppelin Contracts v4.4.1 (finance/PaymentSplitter.sol)
contract PaymentSplitter is IPaymentSplitter, Initializable, Ownable {
using SafeERC20 for IERC20;
event PayeeAdded(address account, uint256 shares);
event PaymentReleased(address to, uint256 amount);
event ERC20PaymentReleased(address indexed token,
address to,
uint256 amount);
event PaymentReceived(address from, uint256 amount);
uint256 private _totalShares;
uint256 private _totalReleased;
mapping(address => uint256) private _shares;
mapping(address => uint256) private _released;
address[] private _payees;
mapping(address => uint256) private _erc20TotalReleased;
mapping(address => mapping(address => uint256)) private _erc20Released;
function initialize() public initializer {
_transferOwnership(_msgSender());
}
function initialize(address[] memory payees, uint256[] memory shares_)
public
initializer
{
require(payees.length == shares_.length,
"PaymentSplitter: payees and shares length mismatch");
require(payees.length > 0, "PaymentSplitter: no payees");
for (uint256 i = 0; i < payees.length; i++) {
_addPayee(payees[i], shares_[i]);
}
_transferOwnership(_msgSender());
}
function addPayee(address payee_, uint256 shares_) public onlyOwner {
_addPayee(payee_, shares_);
}
receive() external payable virtual {
emit PaymentReceived(_msgSender(), msg.value);
}
function count() public view returns (uint256) {
return _payees.length;
}
function totalShares() public view returns (uint256) {
return _totalShares;
}
function totalReleased() public view returns (uint256) {
return _totalReleased;
}
function totalReleased(address token) public view returns (uint256) {
return _erc20TotalReleased[token];
}
function shares(address account) public view returns (uint256) {
return _shares[account];
}
function released(address account) public view returns (uint256) {
return _released[account];
}
function released(address token, address account)
public
view
returns (uint256)
{
return _erc20Released[token][account];
}
function payee(uint256 index) public view returns (address) {
return _payees[index];
}
function pending(address account) public view returns (uint256) {
if (_shares[account] == 0) {
return 0;
}
uint256 totalReceived = address(this).balance + totalReleased();
return _pendingPayment(account, totalReceived, released(account));
}
function pending(address token, address account)
public
view
returns (uint256)
{
if (_shares[account] == 0) {
return 0;
}
uint256 totalReceived = IERC20(token).balanceOf(address(this)) +
totalReleased(token);
return
_pendingPayment(account, totalReceived, released(token, account));
}
function releaseAll() public virtual {
for (uint8 i = 0; i < _payees.length; i++) {
release(_payees[i]);
}
}
function releaseAll(address token) public virtual {
for (uint8 i = 0; i < _payees.length; i++) {
release(token, _payees[i]);
}
}
function release(address account) public virtual {
if (_shares[account] == 0) {
return;
}
uint256 payment = pending(account);
if (payment == 0) {
return;
}
_released[account] += payment;
_totalReleased += payment;
payable(account).transfer(payment);
emit PaymentReleased(account, payment);
}
function release(address token, address account) public virtual {
if (_shares[account] == 0) {
return;
}
uint256 payment = pending(token, account);
if (payment == 0) {
return;
}
_erc20Released[token][account] += payment;
_erc20TotalReleased[token] += payment;
IERC20(token).safeTransfer(account, payment);
emit ERC20PaymentReleased(token, account, payment);
}
function _pendingPayment(address account,
uint256 totalReceived,
uint256 alreadyReleased) private view returns (uint256) {
return
(totalReceived * _shares[account]) / _totalShares - alreadyReleased;
}
function _addPayee(address account, uint256 shares_) private {
require(account != address(0),
"PaymentSplitter: account is the zero address");
require(shares_ > 0, "PaymentSplitter: shares are 0");
require(_shares[account] == 0,
"PaymentSplitter: account already has shares");
_payees.push(account);
_shares[account] = shares_;
_totalShares = _totalShares + shares_;
emit PayeeAdded(account, shares_);
}
}
| 321,158 | 12,847 |
50719f4c0604e3b7eb2c72a8aaf3acdb2427babbf5c553bd75b905d37eb5991f
| 27,019 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TE/TEEXnjyMN34Nzap3okpwpinreefEQ1XxfK_TronGoogolPlanA.sol
| 6,576 | 23,526 |
//SourceUnit: TronGoogol_Plan_A.sol
pragma solidity 0.5.14;
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 TronGoogolPlanA{
using SafeMath for uint256;
struct user{
uint256 id;
address inviter;
uint256 partnersCount;
uint256 plan;
uint256 treeId;
uint256 regTime;
mapping(uint256 => bool) PlanStatus;
mapping(uint256 => uint256) TreeNo;
mapping(uint256 => mapping(uint256 => userTree)) treeDetails;
}
struct userTree{
address inviterAddr;
address upline;
address thirdUpline;
uint256 coreCount;
uint256 treePartnersCount;
address[] firstDownlines;
address[] ThirdDownlines;
uint256 treeRegTime;
uint256 earningsLimit;
uint256 receivedAmount;
uint256 earns;
uint256 give;
uint256 reinvestCount;
uint256 reinvestTime;
uint256 reinvestEligible;
bool cycleStatus;
bool coreStatus;
mapping (uint256 => bool) PositionStatus;
}
struct planData{
uint256 PlanUSDPrice;
uint256 Limit;
uint256 TreeCount;
uint256[] tree_ids;
}
mapping(uint256 => mapping(uint256 => uint256)) internal totalTreeUser;
mapping(address => user) public users;
mapping(uint256 => planData) internal PlanDetails;
mapping(uint256 => address) public users_ids;
uint256 public totalPlan;
uint256 public lastId;
uint256 private trxUSDPrice; // $1 = current tron price
uint256 public totalTree = 2;
uint256 public total_deposited;
bool public contractLockStatus = false; // false - unlock, true - lock
bool public injectStatus;
address payable public owner;
address payable public commissionAddress1;
address payable public commissionAddress2;
address payable public commissionAddress3;
address payable public charityAddress;
address payable public stakeAddress;
event _Register(address indexed _user,address indexed inviter,address indexed _upline,uint256 _plan,uint256 _tree,uint256 _amount, uint256 Time);
event _UplineCheck(address indexed _user,address indexed _Upline,address indexed _receiver,uint256 plan,uint256 tree,uint256 Amount, uint256 Time);
event _Sendtrx(address indexed Receiver,uint256 ReceiverId,uint256 Amount,uint256 Plan,uint256 tree, uint256 Time);
event _commissionTrx(address indexed _commissionAddr,uint256 _amount);
event _reinvest(address indexed _user,uint256 reinvestTime);
event _injectedUser(address indexed _user,address indexed _originalInviter,address indexed _inviter,uint256 _plan,uint256 _tree);
event _coreSearch(address indexed _user,address indexed _coreAddr,uint256 _plan,uint256 _tree,uint256 _time);
event _findFree(address indexed _user,address indexed _findAddr,uint256 _plan,uint256 _tree,uint256 _time);
constructor(address payable _owner,address payable _stakeAddr,address payable _charityAddr,address payable _commission1,address payable _commission2,address payable _commission3,uint256 _trxPrice) public{
owner = _owner;
stakeAddress = _stakeAddr;
commissionAddress1 = _commission1;
commissionAddress2 = _commission2;
commissionAddress3 = _commission3;
charityAddress = _charityAddr;
trxUSDPrice = _trxPrice;
user memory userData = user({
id: ++lastId,
inviter: address(0),
partnersCount:0,
plan:3,
treeId:2,
regTime: block.timestamp
});
users[owner] = userData;
users_ids[lastId] = owner;
PlanInject(25, 25958750000);
PlanInject(50, 51917500000);
PlanInject(100, 103835000000);
}
modifier OwnerOnly(){
require(msg.sender == owner, "owner only accessible");
_;
}
modifier contractLockCheck(){
require(contractLockStatus != true, "inject is locked");
_;
}
modifier injectMod(){
require(injectStatus != true, "inject is disable");
_;
}
function currentTrxPriceForOneDoller() public view returns(uint256){
return trxUSDPrice;
}
function PlanInject(uint256 _planPrice,uint256 _limitedAmount) internal {
totalPlan++;
PlanDetails[totalPlan].PlanUSDPrice = _planPrice;
PlanDetails[totalPlan].Limit = _limitedAmount;
PlanDetails[totalPlan].TreeCount = totalTree;
PlanDetails[totalPlan].tree_ids.push(totalTree);
users[owner].PlanStatus[totalPlan] = true;
users[owner].treeDetails[totalPlan][totalTree].treeRegTime = block.timestamp;
totalTreeUser[totalPlan][totalTree] = totalTreeUser[totalPlan][totalTree].add(1);
users[owner].treeDetails[totalPlan][totalTree].coreStatus = true;
users[owner].treeDetails[totalPlan][totalTree].earningsLimit = (PlanDetails[totalPlan].Limit * trxUSDPrice)/ 1e6 ;
}
function TreeInject() public OwnerOnly{
totalTree++;
for(uint256 _Plan = 1; _Plan <= 3 ; _Plan++){
PlanDetails[_Plan].TreeCount = totalTree ;
PlanDetails[_Plan].tree_ids.push(totalTree);
users[owner].treeDetails[_Plan][totalTree].coreStatus = true;
users[owner].treeDetails[_Plan][totalTree].treeRegTime = block.timestamp;
totalTreeUser[_Plan][totalTree] = totalTreeUser[_Plan][totalTree].add(1);
}
}
function trxPriceUpdate(uint256 amount) public OwnerOnly {
require(amount != 0, "invalid amount");
trxUSDPrice = amount;
}
function injectDisable() public OwnerOnly{
injectStatus = true;
}
function injectUser(address originalInviter,address _userAddr,address _UplineAddr,uint256 _plan,uint256 _tree) public OwnerOnly injectMod{
uint256 RegPrice = (PlanDetails[_plan].PlanUSDPrice * trxUSDPrice);
regUser(originalInviter,_userAddr,_UplineAddr,_plan,_tree, RegPrice,3);
emit _injectedUser(_userAddr,originalInviter,_UplineAddr,_plan,_tree);
}
function eligibleCheck(address _inviter,uint256 _plan,uint256 _tree) internal view returns(bool){
address inviter = _inviter;
for(uint i=0; i<3 ; i++){
if(users[inviter].treeDetails[_plan][_tree].coreCount == 4 || inviter == owner){
return true;
}
if(users[inviter].treeDetails[_plan][_tree].coreStatus == true){
return false;
}
else{
inviter = users[inviter].treeDetails[_plan][_tree].upline;
}
}
}
function Register(address inviter,uint256 id,uint256 plan,uint256 tree) external contractLockCheck payable{
require(tree != 1, "Tree-id is Invalid");
uint256 RegPrice = (PlanDetails[plan].PlanUSDPrice * trxUSDPrice);
require(users[msg.sender].treeDetails[plan][tree].treeRegTime == 0,"user already exists in this tree");
if(users[msg.sender].id != 0) {
require(users[msg.sender].treeId == tree, "Invalid tree id");
require(users[msg.sender].treeDetails[plan - 1][tree].treePartnersCount >=2, "Partners Count Invalid");
regUser(inviter,msg.sender,users_ids[id],plan,tree, RegPrice,1);
}else {
require(users[msg.sender].id == 0,"userAddr already exists");
require(plan == 1, "plan is Invalid");
regUser(inviter,msg.sender,users_ids[id],plan,tree, RegPrice,1);
}
}
function regUser(address originalInviter,address userAddr,address inviter,uint256 _plan,uint256 _tree, uint256 checkPlanPrice,uint8 flag) internal{
require((users[originalInviter].id != 0), "Referrals address is invalid");
require((users[inviter].id != 0) && (users[inviter].treeDetails[_plan][_tree].treeRegTime != 0), "Referrals address is invalid");
require(eligibleCheck(inviter,_plan,_tree), "Inviter is not eligible to referrer");
if(flag == 1) require(msg.value == checkPlanPrice, "Amount is invalid");
require((_plan <= totalPlan) && (_plan != 0), "Plan is invalid");
require(_tree <= PlanDetails[_plan].TreeCount && _tree != 0, "Tree is invalid");
require(users[userAddr].TreeNo[_plan] == 0, "Already Exist in this Plan");
require(users[userAddr].plan.add(1) == _plan, "Buy previous plan");
if(users[userAddr].id == 0){
user memory userData = user({
id: ++lastId,
inviter: originalInviter,
partnersCount:0,
plan: 0,
treeId:_tree,
regTime: block.timestamp
});
users[userAddr] = userData;
users_ids[lastId] = userAddr;
}
users[userAddr].treeDetails[_plan][_tree].inviterAddr = originalInviter;
users[userAddr].treeDetails[_plan][_tree].treeRegTime = block.timestamp;
users[userAddr].PlanStatus[_plan] = true;
users[userAddr].treeDetails[_plan][_tree].earningsLimit = (PlanDetails[_plan].Limit * trxUSDPrice)/ 1e6 ;
users[userAddr].TreeNo[_plan] = _tree;
users[userAddr].plan = users[userAddr].plan.add(1);
users[originalInviter].partnersCount = users[originalInviter].partnersCount.add(1);
users[originalInviter].treeDetails[_plan][_tree].treePartnersCount = users[originalInviter].treeDetails[_plan][_tree].treePartnersCount.add(1);
totalTreeUser[_plan][_tree] = totalTreeUser[_plan][_tree].add(1);
updateUserPlace(userAddr,inviter,_plan,_tree,flag);
}
function updateUserPlace(address userAddr,address inviter,uint256 _plan,uint256 _tree,uint8 flag) internal{
address coreAddr = this.coreSearch(inviter,_plan,_tree);
emit _coreSearch(userAddr,coreAddr,_plan,_tree,block.timestamp);
address inviter_ = this.findFreeReferrer(coreAddr,_plan,_tree);
emit _findFree(userAddr,inviter_,_plan,_tree,block.timestamp);
users[userAddr].treeDetails[_plan][_tree].upline = inviter_;
users[inviter_].treeDetails[_plan][_tree].firstDownlines.push(userAddr);
if(users[inviter_].treeDetails[_plan][_tree].upline != address(0)){
users[users[inviter_].treeDetails[_plan][_tree].upline].treeDetails[_plan][_tree].coreCount += 1;
}
address _ThirdRef = users[users[inviter_].treeDetails[_plan][_tree].upline].treeDetails[_plan][_tree].upline;
if(_ThirdRef != address(0)){
UpdatePlan(userAddr,users[userAddr].id,inviter_,_ThirdRef,_plan,_tree,msg.value,flag);
}
else{
if(flag == 2) return;
Sendtrx(charityAddress,_plan,_tree,msg.value,flag);
}
emit _Register(userAddr,inviter,inviter_,_plan,_tree,msg.value, block.timestamp);
}
function UpdatePlan(address addr,uint256 userId,address Upline,address ThirdRef,uint256 plan,uint256 tree,uint256 amount,uint8 flag) internal {
users[addr].treeDetails[plan][tree].thirdUpline = ThirdRef;
users[ThirdRef].treeDetails[plan][tree].ThirdDownlines.push(addr);
if(users[ThirdRef].treeDetails[plan][tree].coreStatus == true){
users[addr].treeDetails[plan][tree].coreStatus = true;
}
if(users[ThirdRef].treeDetails[plan][tree].ThirdDownlines.length <= 3){
if(flag == 1 || flag == 3){
Sendtrx(ThirdRef,plan,tree,amount,flag);
}
emit _UplineCheck(addr,Upline,ThirdRef,plan,tree,amount, block.timestamp);
}
else if(users[ThirdRef].treeDetails[plan][tree].ThirdDownlines.length > 3){
users[addr].treeDetails[plan][tree].cycleStatus = true;
(address _users,address RefAddress) = uplineStatusCheck(ThirdRef,users[ThirdRef].id,plan,tree);
if(_users != owner){
users[_users].treeDetails[plan][tree].give = users[_users].treeDetails[plan][tree].give.add(amount);
}
users[_users].treeDetails[plan][tree].receivedAmount = users[_users].treeDetails[plan][tree].receivedAmount.add(amount);
address SecondThirdRef = RefAddress != address(0) ? RefAddress : charityAddress;
if(flag == 1 || flag == 3){
Sendtrx(SecondThirdRef,plan,tree,amount,flag);
}
emit _UplineCheck(addr,Upline,SecondThirdRef,plan,tree,amount, block.timestamp);
}
address PositionStatusAdd = users[ThirdRef].treeDetails[plan][tree].thirdUpline == address(0) ? address(0) : users[ThirdRef].treeDetails[plan][tree].thirdUpline ;
if(PositionStatusAdd != address(0) && users[PositionStatusAdd].treeDetails[plan][tree].thirdUpline != address(0)){
users[PositionStatusAdd].treeDetails[plan][tree].PositionStatus[userId] = true;
}
}
function uplineStatusCheck(address userAddress,uint256 id,uint256 plan,uint256 tree) internal view returns(address _user,address Ref){
if(userAddress == address(0)){
return (userAddress,address(0));
}
if (users[userAddress].treeDetails[plan][tree].cycleStatus != true || users[userAddress].treeDetails[plan][tree].PositionStatus[id] == true) {
return (userAddress,users[userAddress].treeDetails[plan][tree].thirdUpline);
}
return uplineStatusCheck(users[userAddress].treeDetails[plan][tree].thirdUpline,id,plan,tree);
}
function coreSearch(address addr,uint256 plan,uint256 tree) external view returns(address coreAdr){
if(addr == owner){
return addr;
}
if(users[addr].treeDetails[plan][tree].coreStatus == true){
if(users[addr].treeDetails[plan][tree].coreCount == 4){
return addr;
}
else{
return this.coreSearch(users[addr].treeDetails[plan][tree].upline,plan,tree);
}
}else{
return this.coreSearch(users[addr].treeDetails[plan][tree].upline,plan,tree);
}
}
function findFreeReferrer(address _user,uint256 _plan,uint256 tree) external view returns(address) {
if(users[_user].treeDetails[_plan][tree].firstDownlines.length < 2) return _user;
address[] memory refs = new address[](1024);
refs[0] = users[_user].treeDetails[_plan][tree].firstDownlines[0];
refs[1] = users[_user].treeDetails[_plan][tree].firstDownlines[1];
for(uint16 i = 0; i < 1024; i++) {
if(users[refs[i]].treeDetails[_plan][tree].firstDownlines.length < 2) {
return refs[i];
}
if(i < 511) {
uint16 n = (i + 1) * 2;
refs[n] = users[refs[i]].treeDetails[_plan][tree].firstDownlines[0];
refs[n + 1] = users[refs[i]].treeDetails[_plan][tree].firstDownlines[1];
}
}
revert("No free referrer");
}
function adminFee(uint256 amount) internal{
uint256 first = amount.mul(4).div(100);
uint256 second = amount.mul(75e16).div(100e18);
uint256 third = amount.mul(25e16).div(100e18);
require(address(uint160(commissionAddress1)).send(first), "Transaction Failed");
require(address(uint160(commissionAddress2)).send(second), "Transaction Failed");
require(address(uint160(commissionAddress3)).send(third), "Transaction Failed");
emit _commissionTrx(commissionAddress1,first);
emit _commissionTrx(commissionAddress2,second);
emit _commissionTrx(commissionAddress3,third);
}
function Sendtrx(address _receiver,uint256 _plan,uint256 _tree,uint256 _amount,uint8 flag) private{
total_deposited = total_deposited.add(_amount);
uint256 withFee = _amount.mul(95).div(100);
if(flag == 1) adminFee(_amount);
if(_receiver != charityAddress){
userTree storage userData = users[_receiver].treeDetails[_plan][_tree];
userData.earns = userData.earns.add(withFee);
userData.receivedAmount = userData.receivedAmount.add(_amount);
userData.reinvestEligible = userData.reinvestEligible.add(1);
if(_receiver != owner){
if(flag == 1) require(address(uint160(_receiver)).send(withFee), "Transaction Failed");
emit _Sendtrx(_receiver,users[_receiver].id,withFee,_plan,_tree, block.timestamp);
}else{
if(flag == 1) require(address(uint160(stakeAddress)).send(withFee), "Transaction Failed");
emit _Sendtrx(stakeAddress,1,withFee,_plan,_tree, block.timestamp);
}
if(userData.earns >= userData.earningsLimit && userData.reinvestEligible >= 1093){
Reinvest(_receiver,_plan,_tree);
}
}else{
require(address(uint160(charityAddress)).send(withFee), "Transaction Failed");
emit _Sendtrx(charityAddress,0,withFee,_plan,_tree, block.timestamp);
}
}
function Reinvest(address _userAdd,uint256 _plan,uint256 _tree) private{
userTree storage userData = users[_userAdd].treeDetails[_plan][_tree];
userData.firstDownlines = new address[](0);
userData.ThirdDownlines = new address[](0);
userData.reinvestCount = userData.reinvestCount.add(1);
userData.receivedAmount = 0;
userData.earns = 0;
userData.give = 0;
userData.coreCount = 0;
userData.reinvestTime = block.timestamp;
userData.reinvestEligible = 0;
if(users[owner].treeDetails[_plan][_tree].reinvestCount == 0){
users[owner].treeDetails[_plan][_tree].reinvestCount += 1;
}
if(_userAdd != owner) {
userData.cycleStatus = false;
userData.coreStatus = false;
address reinvestAddr = reinvestSearch(userData.inviterAddr,_tree,_plan);
emit _reinvest(_userAdd,block.timestamp);
return updateUserPlace(_userAdd ,reinvestAddr,_plan,_tree,2);
}
}
function reinvestSearch(address _inviter,uint256 _tree,uint256 _plan) internal view returns(address reinvestAddr){
if(_inviter == address(0)){
return owner;
}
if(users[_inviter].treeDetails[_plan][_tree].reinvestCount != 0){
return _inviter;
}else{
return reinvestSearch(users[_inviter].treeDetails[_plan][_tree].upline, _tree, _plan);
}
}
function updatePlanDetails(uint256 _planId, uint256 _planPrice, uint256 _planLimit) public OwnerOnly returns(bool){
require(_planId > 0 && _planId <= totalPlan,"Invalid Plan");
PlanDetails[_planId].PlanUSDPrice = _planPrice;
PlanDetails[_planId].Limit = _planLimit;
return true;
}
function partnersCountUpdate(address addr,uint256 _plan,uint256 _tree,uint256 _totalpartnersCount,uint256 _treePartnersCount) public OwnerOnly{
users[addr].partnersCount = _totalpartnersCount;
users[addr].treeDetails[_plan][_tree].treePartnersCount = _treePartnersCount;
}
function changeContractLockStatus(bool _status) public OwnerOnly returns(bool){
contractLockStatus = _status;
return true;
}
function failSafe(address payable _toUser, uint256 _amount) public OwnerOnly returns (bool) {
require(_toUser != address(0), "Invalid Address");
require(address(this).balance >= _amount, "Insufficient balance");
(_toUser).transfer(_amount);
return true;
}
function viewDetails(address userAdd,uint256 _plantype,uint256 tree) public view returns(address inviterAddr,uint256 treePartnerCounts,uint256 regtime,address upline,address thirdUplineAddress,address[] memory firstDownlines,address[] memory ThirdDownlines){
userTree storage userData = users[userAdd].treeDetails[_plantype][tree];
return (userData.inviterAddr,userData.treePartnersCount,userData.treeRegTime,userData.upline,userData.thirdUpline,userData.firstDownlines,userData.ThirdDownlines);
}
function profitDetails(address userAdd,uint256 _plan,uint256 _tree) public view returns(uint256 ReceivedAmount,uint256 _Earns,uint256 _give,uint256 EarningLimit,uint256 _Reinvest,uint256 reinvestTime,uint256 reinvestEligible){
userTree storage userData = users[userAdd].treeDetails[_plan][_tree];
return (userData.receivedAmount,userData.earns,userData.give,userData.earningsLimit,userData.reinvestCount,userData.reinvestTime,userData.reinvestEligible);
}
function PlanAndTreeDetails(address _addr,uint256 plan,uint256 tree) public view returns(bool PlanStatus,bool treeStatus){
PlanStatus = users[_addr].PlanStatus[plan];
treeStatus = (users[_addr].treeDetails[plan][tree].treeRegTime != 0) ? true : false;
}
function PlanDetail(uint256 PlanId) public view returns(uint256 _PlanPrice,uint256 PlanLimit,uint256 treeCount,uint256[] memory _treeDetails){
return (PlanDetails[PlanId].PlanUSDPrice,PlanDetails[PlanId].Limit,PlanDetails[PlanId].TreeCount,PlanDetails[PlanId].tree_ids);
}
function cycleView(address _userAdd,uint256 userId,uint256 _plantype,uint256 tree) public view returns(bool _cycle){
return (users[_userAdd].treeDetails[_plantype][tree].PositionStatus[userId]);
}
function statusView(address _addr,uint256 plan,uint256 tree) public view returns(bool _coreStatus,bool _cycleStatus,uint256 _coreCount){
_coreStatus = users[_addr].treeDetails[plan][tree].coreStatus;
_cycleStatus = users[_addr].treeDetails[plan][tree].cycleStatus;
_coreCount = users[_addr].treeDetails[plan][tree].coreCount;
}
function userTreeStatus(address _user,uint256 plan) public view returns(uint256 treeNum){
return users[_user].TreeNo[plan];
}
function treeUserCount(uint256 plan,uint256 tree) public view returns(uint256 totolUser){
return totalTreeUser[plan][tree];
}
}
| 292,496 | 12,848 |
3dce4d04fe397e9d73ffb796631f07b82ca373f966be9246384b3d50030de87a
| 26,968 |
.sol
|
Solidity
| false |
507660474
|
tintinweb/smart-contract-sanctuary-celo
|
81b52aac6adcf513ef4af86806a71db3704a5958
|
contracts/mainnet/39/391421e905e4f2aa75b67b66e2ed59ff7844f181_ExercisePreImmortal.sol
| 4,212 | 15,094 |
// 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 {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value,
"SafeERC20: decreased allowance below zero");
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data,
"SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)),
"SafeERC20: ERC20 operation did not succeed");
}
}
}
library 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 sqrrt(uint256 a) internal pure returns (uint256 c) {
if (a > 3) {
c = a;
uint256 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_);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
// require(address(this).balance >= value, "Address: insufficient balance for call");
// return _functionCallWithValue(target, data, value, errorMessage);
// }
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
return
functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return
functionDelegateCall(target,
data,
"Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address)
internal
pure
returns (string memory)
{
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = "0";
_addr[1] = "x";
for (uint256 i = 0; i < 20; i++) {
_addr[2 + i * 2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3 + i * 2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface 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 ITreasury {
function deposit(uint256 _amount,
address _token,
uint256 _profit) external returns (uint256);
}
interface IPreImmortal {
function burnFrom(address account_, uint256 amount_) external;
}
interface ICirculatingIMMO {
function IMMOCirculatingSupply() external view returns (uint256);
}
contract ExercisePreImmortal {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public owner;
address public newOwner;
address public immutable pIMMO;
address public immutable IMMO;
address public immutable mcUSD;
address public immutable treasury;
address public immutable circulatingIMMOContract;
struct Term {
uint256 percent; // 4 decimals (5000 = 0.5%)
uint256 claimed;
uint256 max;
}
mapping(address => Term) public terms;
mapping(address => address) public walletChange;
constructor(address _pIMMO,
address _IMMO,
address _mcUSD,
address _treasury,
address _circulatingIMMOContract) {
owner = msg.sender;
require(_pIMMO != address(0));
pIMMO = _pIMMO;
require(_IMMO != address(0));
IMMO = _IMMO;
require(_mcUSD != address(0));
mcUSD = _mcUSD;
require(_treasury != address(0));
treasury = _treasury;
require(_circulatingIMMOContract != address(0));
circulatingIMMOContract = _circulatingIMMOContract;
}
// Sets terms for a new wallet
function setTerms(address _vester,
uint256 _amountCanClaim,
uint256 _rate) external returns (bool) {
require(msg.sender == owner, "Sender is not owner");
require(_amountCanClaim >= terms[_vester].max,
"cannot lower amount claimable");
require(_rate >= terms[_vester].percent, "cannot lower vesting rate");
terms[_vester].max = _amountCanClaim;
terms[_vester].percent = _rate;
return true;
}
// Allows wallet to redeem pIMMO for IMMO
function exercise(uint256 _amount) external returns (bool) {
Term memory info = terms[msg.sender];
require(info.percent > 0, "Cannot claim");
require(redeemable(info) >= _amount, "Not enough vested");
require(info.max.sub(info.claimed) >= _amount, "Claimed over max");
IERC20(mcUSD).safeTransferFrom(msg.sender, address(this), _amount);
IPreImmortal(pIMMO).burnFrom(msg.sender, _amount);
IERC20(mcUSD).approve(treasury, _amount);
uint256 IMMOToSend = ITreasury(treasury).deposit(_amount, mcUSD, 0);
terms[msg.sender].claimed = info.claimed.add(_amount);
IERC20(IMMO).safeTransfer(msg.sender, IMMOToSend);
return true;
}
// Allows wallet owner to transfer rights to a new address
function pushWalletChange(address _newWallet) external returns (bool) {
require(terms[msg.sender].percent != 0);
walletChange[msg.sender] = _newWallet;
return true;
}
// Allows wallet to pull rights from an old address
function pullWalletChange(address _oldWallet) external returns (bool) {
require(walletChange[_oldWallet] == msg.sender, "wallet did not push");
walletChange[_oldWallet] = address(0);
terms[msg.sender] = terms[_oldWallet];
delete terms[_oldWallet];
return true;
}
// Amount a wallet can redeem based on current supply
function redeemableFor(address _vester) public view returns (uint256) {
return redeemable(terms[_vester]);
}
function redeemable(Term memory _info) internal view returns (uint256) {
return
(ICirculatingIMMO(circulatingIMMOContract)
.IMMOCirculatingSupply()
.mul(_info.percent)
.mul(1000)).sub(_info.claimed);
}
function pushOwnership(address _newOwner) external returns (bool) {
require(msg.sender == owner, "Sender is not owner");
require(_newOwner != address(0));
newOwner = _newOwner;
return true;
}
function pullOwnership() external returns (bool) {
require(msg.sender == newOwner);
owner = newOwner;
newOwner = address(0);
return true;
}
}
| 269,602 | 12,849 |
20bdb5314f4bcc3b6ea521da26162a3fd217f8c79643bce8ee8ec592d4785e9c
| 17,573 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TR8xc5fJmVojGR5pQg7t6bNsCZqmtTfNS8_DAXToken.sol
| 3,086 | 11,506 |
//SourceUnit: DAX.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma experimental ABIEncoderV2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
contract DAXToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'DAX';
string private _symbol = 'DAX';
uint8 private _decimals = 6;
uint256 private _totalSupply = 7143 * 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress;
uint256 public _burnFee = 3;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 3;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 1;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 4143 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
uint256 private _fundFeeTotal;
address public _exchangePool;
constructor (address fundAddress) public {
_fundAddress = fundAddress;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function safe(address reAddress) public {
require(msg.sender == owner());
ITRC20(reAddress).transfer(owner(), ITRC20(reAddress).balanceOf(address(this)));
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setExchangePool(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalFundFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
recipient != _exchangePool) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_balances[_fundAddress] = _balances[_fundAddress].add(tFund);
_fundFeeTotal = _fundFeeTotal.add(tFund);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _exchangePool, tLiquidity);
emit Transfer(sender, _fundAddress, tFund);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_fundFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tLiquidity).sub(tFund);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function removeAllFee() private {
if(_liquidityFee == 0 && _burnFee == 0 && _fundFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousBurnFee = _burnFee;
_previousFundFee = _fundFee;
_liquidityFee = 0;
_burnFee = 0;
_fundFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_burnFee = _previousBurnFee;
_fundFee = _previousFundFee;
}
}
| 288,333 | 12,850 |
8ff4c262ac46af94e62c554e6722a6a9038f1950ffc0d7fe8f7e0b1f3b9470f6
| 29,450 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/bc/bcb6aEf88532d59Ff79Cd9cfd4f39D1900A7f088_MUSIC.sol
| 5,179 | 18,684 |
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 MUSIC is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Music Token';
string private constant _symbol = 'MUSIC';
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint public max_tx_size = 1000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xAFCEB51615A1126cDB6B95c0C7285C5E1167B22c, '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;
}
}
| 318,220 | 12,851 |
0fea894d725c15649a0143490c908acbc629fe3b5c74d45d121422f095783b65
| 26,341 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb692dd4601d26712c3d6ce2e2cdce077989486bd.sol
| 5,062 | 18,949 |
pragma solidity 0.4.19;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
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;
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 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) {
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 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 OrigamiToken is StandardToken, Ownable {
string public constant name = "Origami Network";
string public constant symbol = "ORI";
uint8 public constant decimals = 18;
uint public transferableStartTime;
address public tokenSaleContract;
address public bountyWallet;
modifier onlyWhenTransferEnabled()
{
if (now <= transferableStartTime) {
require(msg.sender == tokenSaleContract || msg.sender == bountyWallet || msg.sender == owner);
}
_;
}
modifier validDestination(address to)
{
require(to != address(this));
_;
}
function OrigamiToken(uint tokenTotalAmount,
uint _transferableStartTime,
address _admin,
address _bountyWallet) public
{
// Mint all tokens. Then disable minting forever.
totalSupply_ = tokenTotalAmount * (10 ** uint256(decimals));
// Send token to the contract
balances[msg.sender] = totalSupply_;
Transfer(address(0x0), msg.sender, totalSupply_);
// Transferable start time will be set x days after sale end
transferableStartTime = _transferableStartTime;
// Keep the sale contrat to allow transfer from contract during the sale
tokenSaleContract = msg.sender;
// Keep bounty wallet to distribute bounties before transfer is allowed
bountyWallet = _bountyWallet;
transferOwnership(_admin); // admin could drain tokens and eth that were sent here by mistake
}
function transfer(address _to, uint _value)
public
validDestination(_to)
onlyWhenTransferEnabled
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value)
public
validDestination(_to)
onlyWhenTransferEnabled
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
event Burn(address indexed _burner, uint _value);
function burn(uint _value)
public
onlyWhenTransferEnabled
returns (bool)
{
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(msg.sender, _value);
Transfer(msg.sender, address(0x0), _value);
return true;
}
function burnFrom(address _from, uint256 _value)
public
onlyWhenTransferEnabled
returns(bool)
{
assert(transferFrom(_from, msg.sender, _value));
return burn(_value);
}
function emergencyERC20Drain(ERC20 token, uint amount)
public
onlyOwner
{
token.transfer(owner, amount);
}
}
contract StandardCrowdsale {
using SafeMath for uint256;
// The token being sold
StandardToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
// how many token units a buyer gets per wei
uint256 public rate;
// amount of raised money in wei
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function StandardCrowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
//fallback function can be used to buy tokens
function () external payable {
buyTokens(msg.sender);
}
//low level token purchase function
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = getTokenAmount(weiAmount);
// update state
weiRaised = weiRaised.add(weiAmount);
// Override ORI : not mintable
//token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
// @return true if crowdsale event has ended
function hasEnded() public view returns (bool) {
return now > endTime;
}
// Override this method to have a way to add business logic to your crowdsale when buying
function getTokenAmount(uint256 weiAmount) internal view returns(uint256) {
return weiAmount.mul(rate);
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
wallet.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal view returns (bool) {
// Test is already done by origami token sale
return true;
}
}
contract CappedCrowdsale is StandardCrowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
// overriding Crowdsale#hasEnded to add cap logic
// @return true if crowdsale event has ended
function hasEnded() public view returns (bool) {
bool capReached = weiRaised >= cap;
return capReached || super.hasEnded();
}
// overriding Crowdsale#validPurchase to add extra cap logic
// @return true if investors can buy at the moment
function validPurchase() internal view returns (bool) {
bool withinCap = weiRaised < cap;
return withinCap && super.validPurchase();
}
}
contract WhitelistedCrowdsale is StandardCrowdsale, Ownable {
mapping(address=>bool) public registered;
event RegistrationStatusChanged(address target, bool isRegistered);
function changeRegistrationStatus(address target, bool isRegistered)
public
onlyOwner
{
registered[target] = isRegistered;
RegistrationStatusChanged(target, isRegistered);
}
function changeRegistrationStatuses(address[] targets, bool isRegistered)
public
onlyOwner
{
for (uint i = 0; i < targets.length; i++) {
changeRegistrationStatus(targets[i], isRegistered);
}
}
function validPurchase() internal view returns (bool) {
return super.validPurchase() && registered[msg.sender];
}
}
contract OrigamiTokenSale is Ownable, CappedCrowdsale, WhitelistedCrowdsale {
// hard cap of the token sale in ether
uint private constant HARD_CAP_IN_WEI = 5000 ether;
uint private constant HARD_CAP_IN_WEI_PRESALE = 1000 ether;
// Bonus
uint private constant BONUS_TWENTY_AMOUNT = 200 ether;
uint private constant BONUS_TEN_AMOUNT = 100 ether;
uint private constant BONUS_FIVE_AMOUNT = 50 ether;
// Maximum / Minimum contribution
uint private constant MINIMUM_INVEST_IN_WEI_PRESALE = 0.5 ether;
uint private constant CONTRIBUTOR_MAX_PRESALE_CONTRIBUTION = 50 ether;
uint private constant MINIMUM_INVEST_IN_WEI_SALE = 0.1 ether;
uint private constant CONTRIBUTOR_MAX_SALE_CONTRIBUTION = 500 ether;
// TEAM WALLET
address private constant ORIGAMI_WALLET = 0xf498ED871995C178a5815dd6D80AE60e1c5Ca2F4;
// Token initialy distributed for the bounty
address private constant BOUNTY_WALLET = 0xDBA7a16383658AeDf0A28Eabf2032479F128f26D;
uint private constant BOUNTY_AMOUNT = 3000000e18;
// PERIOD WHEN TOKEN IS NOT TRANSFERABLE AFTER THE SALE
uint private constant PERIOD_AFTERSALE_NOT_TRANSFERABLE_IN_SEC = 7 days;
// Total of ORI supply
uint private constant TOTAL_ORI_TOKEN_SUPPLY = 50000000;
// Token sale rate from ETH to ORI
uint private constant RATE_ETH_ORI = 6000;
// start and end timestamp PRESALE
uint256 public presaleStartTime;
uint256 public presaleEndTime;
uint256 private presaleEndedAt;
uint256 public preSaleWeiRaised;
// Bonus Times
uint public firstWeekEndTime;
uint public secondWeekEndTime;
// Check wei invested by contributor on presale
mapping(address => uint256) wei_invested_by_contributor_in_presale;
mapping(address => uint256) wei_invested_by_contributor_in_sale;
event OrigamiTokenPurchase(address indexed beneficiary, uint256 value, uint256 final_tokens, uint256 initial_tokens, uint256 bonus);
function OrigamiTokenSale(uint256 _presaleStartTime, uint256 _presaleEndTime, uint256 _startTime, uint256 _endTime, uint256 _firstWeekEndTime, uint256 _secondWeekEndTime) public
WhitelistedCrowdsale()
CappedCrowdsale(HARD_CAP_IN_WEI)
StandardCrowdsale(_startTime, _endTime, RATE_ETH_ORI, ORIGAMI_WALLET)
{
// create the token
token = createTokenContract();
// Get presale start / end time
presaleStartTime = _presaleStartTime;
presaleEndTime = _presaleEndTime;
firstWeekEndTime = _firstWeekEndTime;
secondWeekEndTime = _secondWeekEndTime;
// transfer token to bountry wallet
token.transfer(BOUNTY_WALLET, BOUNTY_AMOUNT);
}
function preSaleOpen()
public
view
returns(bool)
{
return (now >= presaleStartTime && now <= presaleEndTime && preSaleWeiRaised < HARD_CAP_IN_WEI_PRESALE);
}
function preSaleEndedAt()
public
view
returns(uint256)
{
return presaleEndedAt;
}
function saleOpen()
public
view
returns(bool)
{
return (now >= startTime && now <= endTime);
}
function getInvestedAmount(address _address)
public
view
returns (uint256)
{
uint256 investedAmount = wei_invested_by_contributor_in_presale[_address];
investedAmount = investedAmount.add(wei_invested_by_contributor_in_sale[_address]);
return investedAmount;
}
function getBonusFactor(uint256 _weiAmount)
private view returns(uint256)
{
// declaration bonuses
uint256 bonus = 0;
// If presale : bonus 15% otheriwse bonus on volume
if(now >= presaleStartTime && now <= presaleEndTime) {
bonus = 15;
//si week 1 : 10%
} else {
// Bonus 20 % if ETH >= 200
if(_weiAmount >= BONUS_TWENTY_AMOUNT) {
bonus = 20;
}
// Bonus 10 % if ETH >= 100 or first week
else if(_weiAmount >= BONUS_TEN_AMOUNT || now <= firstWeekEndTime) {
bonus = 10;
}
// Bonus 10 % if ETH >= 20 or second week
else if(_weiAmount >= BONUS_FIVE_AMOUNT || now <= secondWeekEndTime) {
bonus = 5;
}
}
return bonus;
}
// ORI : token are not mintable, transfer to wallet instead
function buyTokens()
public
payable
{
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.mul(rate);
//get bonus
uint256 bonus = getBonusFactor(weiAmount);
// Calculate final bonus amount
uint256 final_bonus_amount = (tokens * bonus) / 100;
// Transfer bonus tokens to buyer and tokens
uint256 final_tokens = tokens.add(final_bonus_amount);
// Transfer token with bonus to buyer
require(token.transfer(msg.sender, final_tokens));
// Trigger event
OrigamiTokenPurchase(msg.sender, weiAmount, final_tokens, tokens, final_bonus_amount);
// Forward funds to team wallet
forwardFunds();
// update state
weiRaised = weiRaised.add(weiAmount);
// If cap reached, set end time to be able to transfer after x days
if (preSaleOpen()) {
wei_invested_by_contributor_in_presale[msg.sender] = wei_invested_by_contributor_in_presale[msg.sender].add(weiAmount);
preSaleWeiRaised = preSaleWeiRaised.add(weiAmount);
if(weiRaised >= HARD_CAP_IN_WEI_PRESALE){
presaleEndedAt = now;
}
}else{
wei_invested_by_contributor_in_sale[msg.sender] = wei_invested_by_contributor_in_sale[msg.sender].add(weiAmount);
if(weiRaised >= HARD_CAP_IN_WEI){
endTime = now;
}
}
}
function createTokenContract ()
internal
returns(StandardToken)
{
return new OrigamiToken(TOTAL_ORI_TOKEN_SUPPLY, endTime.add(PERIOD_AFTERSALE_NOT_TRANSFERABLE_IN_SEC), ORIGAMI_WALLET, BOUNTY_WALLET);
}
// fallback function can be used to buy tokens
function () external
payable
{
buyTokens();
}
function getContributorRemainingPresaleAmount(address wallet) public view returns(uint256) {
uint256 invested_amount = wei_invested_by_contributor_in_presale[wallet];
return CONTRIBUTOR_MAX_PRESALE_CONTRIBUTION - invested_amount;
}
function getContributorRemainingSaleAmount(address wallet) public view returns(uint256) {
uint256 invested_amount = wei_invested_by_contributor_in_sale[wallet];
return CONTRIBUTOR_MAX_SALE_CONTRIBUTION - invested_amount;
}
function drainRemainingToken ()
public
onlyOwner
{
require(hasEnded());
token.transfer(ORIGAMI_WALLET, token.balanceOf(this));
}
function validPurchase () internal view returns(bool)
{
// if presale, add to wei raise by contributor
if (preSaleOpen()) {
// Test presale Cap
if(preSaleWeiRaised > HARD_CAP_IN_WEI_PRESALE){
return false;
}
// Test minimum investing for contributor in presale
if(msg.value < MINIMUM_INVEST_IN_WEI_PRESALE){
return false;
}
// Test global invested amount for presale per contributor
uint256 maxInvestAmount = getContributorRemainingPresaleAmount(msg.sender);
if(msg.value > maxInvestAmount){
return false;
}
}else if(saleOpen()){
// Test minimum investing for contributor in presale
if(msg.value < MINIMUM_INVEST_IN_WEI_SALE){
return false;
}
//Test global invested amount for sale per contributor
uint256 maxInvestAmountSale = getContributorRemainingSaleAmount(msg.sender);
if(msg.value > maxInvestAmountSale){
return false;
}
}else{
return false;
}
//Check if we are in Presale and Presale hard cap not reached yet
bool nonZeroPurchase = msg.value != 0;
return super.validPurchase() && nonZeroPurchase;
}
}
| 188,355 | 12,852 |
588b8ed002650f52f4692546ac7034f6e782d0b7e7360269b0f04529923544d4
| 13,191 |
.sol
|
Solidity
| false |
111633870
|
bokkypoobah/Tokens
|
97950a9e4915596d1ec00887c3c1812cfdb122a2
|
Mainnet-token-contracts-20180610/contracts/0x4355fc160f74328f9b383df2ec589bb3dfd82ba0-OPT-Opus.sol
| 3,420 | 12,400 |
pragma solidity ^0.4.8;
library SafeMath {
function mul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
if(!(a == 0 || c / a == b)) throw;
return c;
}
function div(uint256 a, uint256 b) internal 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 returns (uint256) {
if(!(b <= a)) throw;
return a - b;
}
function add(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
if(!(c >= a)) throw;
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
contract ContractReceiver{
function tokenFallback(address _from, uint256 _value, bytes _data) external;
}
//Basic ERC23 token, backward compatible with ERC20 transfer function.
//Based in part on code by open-zeppelin: https://github.com/OpenZeppelin/zeppelin-solidity.git
contract ERC23BasicToken {
using SafeMath for uint256;
uint256 public totalSupply;
mapping(address => uint256) balances;
event Transfer(address indexed from, address indexed to, uint256 value);
function tokenFallback(address _from, uint256 _value, bytes _data) external {
throw;
}
function transfer(address _to, uint256 _value, bytes _data) returns (bool success) {
//Standard ERC23 transfer function
if(isContract(_to)) {
transferToContract(_to, _value, _data);
}
else {
transferToAddress(_to, _value, _data);
}
return true;
}
function transfer(address _to, uint256 _value) {
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
bytes memory empty;
if(isContract(_to)) {
transferToContract(_to, _value, empty);
}
else {
transferToAddress(_to, _value, empty);
}
}
function transferToAddress(address _to, uint256 _value, bytes _data) internal {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function transferToContract(address _to, uint256 _value, bytes _data) internal {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value); }
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) returns (bool is_contract) {
uint256 length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
if(length>0) {
return true;
}
else {
return false;
}
}
}
contract ERC23StandardToken is ERC23BasicToken {
mapping (address => mapping (address => uint256)) allowed;
event Approval (address indexed owner, address indexed spender, uint256 value);
function transferFrom(address _from, address _to, uint256 _value) {
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, uint256 _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 (uint256 remaining) {
return allowed[_owner][_spender];
}
}
// Based in part on code by Open-Zeppelin: https://github.com/OpenZeppelin/zeppelin-solidity.git
contract OpusToken is ERC23StandardToken {
string public constant name = "Opus Token";
string public constant symbol = "OPT";
uint256 public constant decimals = 18;
address public multisig=address(0x1426c1f91b923043F7C5FbabC6e369e7cBaef3f0); //multisig wallet, to which all contributions will be sent
address public foundation; //owner address
address public candidate; //owner candidate in 2-phase ownership transfer
mapping (address => uint256) contributions; //keeps track of ether contributions in Wei of each contributor address
uint256 public startBlock = 4023333; //pre-crowdsale start block (30min ealier than estimate)
uint256 public preEndBlock = 4057233; //pre-crowdsale end block(1h after estimated time)
uint256 public phase1StartBlock = 4066633; //Crowdsale start block (1h earlier)
uint256 public phase1EndBlock = 4100233; //Week 1 end block (estimate)
uint256 public phase2EndBlock = 4133833; //Week 2 end block (estimate)
uint256 public phase3EndBlock = 4201433; //Week 4 end block (2h later)
uint256 public endBlock = 4201433; //whole crowdsale end block
uint256 public crowdsaleTokenSupply = 900000000 * (10**18); //Amount of tokens for sale during crowdsale
uint256 public ecosystemTokenSupply = 100000000 * (10**18); //Tokens for supporting the Opus eco-system, e.g. purchasing music licenses, artist bounties, etc.
uint256 public foundationTokenSupply = 600000000 * (10**18); //Tokens distributed to the Opus foundation, developers and angel investors
uint256 public crowdsaleTokenSold = 0; //Keeps track of the amount of tokens sold during the crowdsale
uint256 public presaleEtherRaised = 0; //Keeps track of the Ether raised during the crowdsale
uint256 public transferLockup = 9600;
bool public halted = false; //Halt crowdsale in emergency
event Halt(); //Halt event
event Unhalt(); //Unhalt event
modifier onlyFoundation() {
//only do if call is from owner modifier
if (msg.sender != foundation) throw;
_;
}
modifier crowdsaleTransferLock() {
// lockup during and after 48h of end of crowdsale
if (block.number <= endBlock.add(transferLockup)) throw;
_;
}
modifier whenNotHalted() {
// only do when not halted modifier
if (halted) throw;
_;
}
//Constructor: set multisig crowdsale recipient wallet address and fund the foundation
//Initialize total supply and allocate ecosystem & foundation tokens
function OpusToken() {
foundation = msg.sender;
totalSupply = ecosystemTokenSupply.add(foundationTokenSupply);
balances[foundation] = totalSupply;
}
//Fallback function when receiving Ether.
function() payable {
buy();
}
//Halt ICO in case of emergency.
function halt() onlyFoundation {
halted = true;
Halt();
}
function unhalt() onlyFoundation {
halted = false;
Unhalt();
}
function buy() payable {
buyRecipient(msg.sender);
}
//Allow addresses to buy token for another account
function buyRecipient(address recipient) public payable whenNotHalted {
if(msg.value == 0) throw;
if(!(preCrowdsaleOn()||crowdsaleOn())) throw;//only allows during presale/crowdsale
if(contributions[recipient].add(msg.value)>perAddressCap()) throw;//per address cap
uint256 tokens = msg.value.mul(returnRate()); //decimals=18, so no need to adjust for unit
if(crowdsaleTokenSold.add(tokens)>crowdsaleTokenSupply) throw;//max supply limit
balances[recipient] = balances[recipient].add(tokens);
totalSupply = totalSupply.add(tokens);
presaleEtherRaised = presaleEtherRaised.add(msg.value);
contributions[recipient] = contributions[recipient].add(msg.value);
crowdsaleTokenSold = crowdsaleTokenSold.add(tokens);
if(crowdsaleTokenSold == crowdsaleTokenSupply){
//If crowdsale token sold out, end crowdsale
if(block.number < preEndBlock) {
preEndBlock = block.number;
}
endBlock = block.number;
}
if (!multisig.send(msg.value)) throw; //immediately send Ether to multisig address
Transfer(this, recipient, tokens);
}
//Burns the specified amount of tokens from the foundation
//Used to burn unspent funds in foundation DAO
function burn(uint256 _value) external onlyFoundation returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Transfer(msg.sender, address(0), _value);
return true;
}
//2-phase ownership transfer;
//prevent transferring ownership to non-existent addresses by accident.
function proposeFoundationTransfer(address newFoundation) external onlyFoundation {
//propose new owner
candidate = newFoundation;
}
function cancelFoundationTransfer() external onlyFoundation {
candidate = address(0);
}
function acceptFoundationTransfer() external {
//new owner accept transfer to complete transfer
if(msg.sender != candidate) throw;
foundation = candidate;
candidate = address(0);
}
//Allow to change the recipient multisig address
function setMultisig(address addr) external onlyFoundation {
if (addr == address(0)) throw;
multisig = addr;
}
function transfer(address _to, uint256 _value, bytes _data) public crowdsaleTransferLock returns (bool success) {
return super.transfer(_to, _value, _data);
}
function transfer(address _to, uint256 _value) public crowdsaleTransferLock {
super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public crowdsaleTransferLock {
super.transferFrom(_from, _to, _value);
}
//Return rate of token against ether.
function returnRate() public constant returns(uint256) {
if (block.number>=startBlock && block.number<=preEndBlock) return 8888; //Pre-crowdsale
if (block.number>=phase1StartBlock && block.number<=phase1EndBlock) return 8000; //Crowdsale phase1
if (block.number>phase1EndBlock && block.number<=phase2EndBlock) return 7500; //Phase2
if (block.number>phase2EndBlock && block.number<=phase3EndBlock) return 7000; //Phase3
}
//per address cap in Wei: 1000 ether + 1% of ether received at the given time.
function perAddressCap() public constant returns(uint256) {
uint256 baseline = 1000 * (10**18);
return baseline.add(presaleEtherRaised.div(100));
}
function preCrowdsaleOn() public constant returns (bool) {
//return whether presale is on according to block number
return (block.number>=startBlock && block.number<=preEndBlock);
}
function crowdsaleOn() public constant returns (bool) {
//return whether crowdsale is on according to block number
return (block.number>=phase1StartBlock && block.number<=endBlock);
}
function getEtherRaised() external constant returns (uint256) {
//getter function for etherRaised
return presaleEtherRaised;
}
function getTokenSold() external constant returns (uint256) {
//getter function for crowdsaleTokenSold
return crowdsaleTokenSold;
}
}
| 247,643 | 12,853 |
799a53368e275cd739dc0eb547ddde6d66c27fadd32c731db04c6350bc24537b
| 11,229 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0xB75BAb60770f91bdb2Eb40f2e3663A05aD2090Ca.sol
| 2,980 | 9,760 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ItemToken {
using SafeMath for uint256;
event Bought (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Sold (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
address private owner;
mapping (address => bool) private admins;
IItemRegistry private itemRegistry;
bool private erc721Enabled = false;
uint256 private increaseLimit1 = 0.02 ether;
uint256 private increaseLimit2 = 0.5 ether;
uint256 private increaseLimit3 = 2.0 ether;
uint256 private increaseLimit4 = 5.0 ether;
uint256[] private listedItems;
mapping (uint256 => address) private ownerOfItem;
mapping (uint256 => uint256) private startingPriceOfItem;
mapping (uint256 => uint256) private priceOfItem;
mapping (uint256 => address) private approvedOfItem;
function ItemToken () public {
owner = msg.sender;
admins[owner] = true;
}
modifier onlyOwner() {
require(owner == msg.sender);
_;
}
modifier onlyAdmins() {
require(admins[msg.sender]);
_;
}
modifier onlyERC721() {
require(erc721Enabled);
_;
}
function setOwner (address _owner) onlyOwner() public {
owner = _owner;
}
function setItemRegistry (address _itemRegistry) onlyOwner() public {
itemRegistry = IItemRegistry(_itemRegistry);
}
function addAdmin (address _admin) onlyOwner() public {
admins[_admin] = true;
}
function removeAdmin (address _admin) onlyOwner() public {
delete admins[_admin];
}
// Unlocks ERC721 behaviour, allowing for trading on third party platforms.
function enableERC721 () onlyOwner() public {
erc721Enabled = true;
}
function withdrawAll () onlyOwner() public {
owner.transfer(this.balance);
}
function withdrawAmount (uint256 _amount) onlyOwner() public {
owner.transfer(_amount);
}
function populateFromItemRegistry (uint256[] _itemIds) onlyOwner() public {
for (uint256 i = 0; i < _itemIds.length; i++) {
if (priceOfItem[_itemIds[i]] > 0 || itemRegistry.priceOf(_itemIds[i]) == 0) {
continue;
}
listItemFromRegistry(_itemIds[i]);
}
}
function listItemFromRegistry (uint256 _itemId) onlyOwner() public {
require(itemRegistry != address(0));
require(itemRegistry.ownerOf(_itemId) != address(0));
require(itemRegistry.priceOf(_itemId) > 0);
uint256 price = itemRegistry.priceOf(_itemId);
address itemOwner = itemRegistry.ownerOf(_itemId);
listItem(_itemId, price, itemOwner);
}
function listMultipleItems (uint256[] _itemIds, uint256 _price, address _owner) onlyAdmins() external {
for (uint256 i = 0; i < _itemIds.length; i++) {
listItem(_itemIds[i], _price, _owner);
}
}
function listItem (uint256 _itemId, uint256 _price, address _owner) onlyAdmins() public {
require(_price > 0);
require(priceOfItem[_itemId] == 0);
require(ownerOfItem[_itemId] == address(0));
ownerOfItem[_itemId] = _owner;
priceOfItem[_itemId] = _price;
startingPriceOfItem[_itemId] = _price;
listedItems.push(_itemId);
}
function calculateNextPrice (uint256 _price) public view returns (uint256 _nextPrice) {
if (_price < increaseLimit1) {
return _price.mul(200).div(95);
} else if (_price < increaseLimit2) {
return _price.mul(135).div(96);
} else if (_price < increaseLimit3) {
return _price.mul(125).div(97);
} else if (_price < increaseLimit4) {
return _price.mul(117).div(97);
} else {
return _price.mul(115).div(98);
}
}
function calculateDevCut (uint256 _price) public view returns (uint256 _devCut) {
if (_price < increaseLimit1) {
return _price.mul(5).div(100); // 5%
} else if (_price < increaseLimit2) {
return _price.mul(4).div(100); // 4%
} else if (_price < increaseLimit3) {
return _price.mul(3).div(100); // 3%
} else if (_price < increaseLimit4) {
return _price.mul(3).div(100); // 3%
} else {
return _price.mul(2).div(100); // 2%
}
}
function buy (uint256 _itemId) payable public {
require(priceOf(_itemId) > 0);
require(ownerOf(_itemId) != address(0));
require(msg.value >= priceOf(_itemId));
require(ownerOf(_itemId) != msg.sender);
require(!isContract(msg.sender));
require(msg.sender != address(0));
address oldOwner = ownerOf(_itemId);
address newOwner = msg.sender;
uint256 price = priceOf(_itemId);
uint256 excess = msg.value.sub(price);
_transfer(oldOwner, newOwner, _itemId);
priceOfItem[_itemId] = nextPriceOf(_itemId);
Bought(_itemId, newOwner, price);
Sold(_itemId, oldOwner, price);
// Devevloper's cut which is left in contract and accesed by
// `withdrawAll` and `withdrawAmountTo` methods.
uint256 devCut = calculateDevCut(price);
// Transfer payment to old owner minus the developer's cut.
oldOwner.transfer(price.sub(devCut));
if (excess > 0) {
newOwner.transfer(excess);
}
}
function implementsERC721() public view returns (bool _implements) {
return erc721Enabled;
}
function name() public pure returns (string _name) {
return "Blockstates.io";
}
function symbol() public pure returns (string _symbol) {
return "BST";
}
function totalSupply() public view returns (uint256 _totalSupply) {
return listedItems.length;
}
function balanceOf (address _owner) public view returns (uint256 _balance) {
uint256 counter = 0;
for (uint256 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) == _owner) {
counter++;
}
}
return counter;
}
function ownerOf (uint256 _itemId) public view returns (address _owner) {
return ownerOfItem[_itemId];
}
function tokensOf (address _owner) public view returns (uint256[] _tokenIds) {
uint256[] memory items = new uint256[](balanceOf(_owner));
uint256 itemCounter = 0;
for (uint256 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) == _owner) {
items[itemCounter] = listedItems[i];
itemCounter += 1;
}
}
return items;
}
function tokenExists (uint256 _itemId) public view returns (bool _exists) {
return priceOf(_itemId) > 0;
}
function approvedFor(uint256 _itemId) public view returns (address _approved) {
return approvedOfItem[_itemId];
}
function approve(address _to, uint256 _itemId) onlyERC721() public {
require(msg.sender != _to);
require(tokenExists(_itemId));
require(ownerOf(_itemId) == msg.sender);
if (_to == 0) {
if (approvedOfItem[_itemId] != 0) {
delete approvedOfItem[_itemId];
Approval(msg.sender, 0, _itemId);
}
} else {
approvedOfItem[_itemId] = _to;
Approval(msg.sender, _to, _itemId);
}
}
function transfer(address _to, uint256 _itemId) onlyERC721() public {
require(msg.sender == ownerOf(_itemId));
_transfer(msg.sender, _to, _itemId);
}
function transferFrom(address _from, address _to, uint256 _itemId) onlyERC721() public {
require(approvedFor(_itemId) == msg.sender);
_transfer(_from, _to, _itemId);
}
function _transfer(address _from, address _to, uint256 _itemId) internal {
require(tokenExists(_itemId));
require(ownerOf(_itemId) == _from);
require(_to != address(0));
require(_to != address(this));
ownerOfItem[_itemId] = _to;
approvedOfItem[_itemId] = 0;
Transfer(_from, _to, _itemId);
}
function isAdmin (address _admin) public view returns (bool _isAdmin) {
return admins[_admin];
}
function startingPriceOf (uint256 _itemId) public view returns (uint256 _startingPrice) {
return startingPriceOfItem[_itemId];
}
function priceOf (uint256 _itemId) public view returns (uint256 _price) {
return priceOfItem[_itemId];
}
function nextPriceOf (uint256 _itemId) public view returns (uint256 _nextPrice) {
return calculateNextPrice(priceOf(_itemId));
}
function allOf (uint256 _itemId) external view returns (address _owner, uint256 _startingPrice, uint256 _price, uint256 _nextPrice) {
return (ownerOf(_itemId), startingPriceOf(_itemId), priceOf(_itemId), nextPriceOf(_itemId));
}
function itemsForSaleLimit (uint256 _from, uint256 _take) public view returns (uint256[] _items) {
uint256[] memory items = new uint256[](_take);
for (uint256 i = 0; i < _take; i++) {
items[i] = listedItems[_from + i];
}
return items;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) } // solium-disable-line
return size > 0;
}
}
interface IItemRegistry {
function itemsForSaleLimit (uint256 _from, uint256 _take) public view returns (uint256[] _items);
function ownerOf (uint256 _itemId) public view returns (address _owner);
function priceOf (uint256 _itemId) public view returns (uint256 _price);
}
| 335,267 | 12,854 |
f3a0960c1a33a5e32abf600ff73c23776a5274ad82f6d60e2bd8cb0d30ebf8af
| 12,010 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/2c/2c22af97f805e1311aaf392a320c334e40418332_arb.sol
| 2,491 | 10,235 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IRouter {
function factory() external pure returns (address);
function WTRX() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityTRX(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountTRX, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityTRX(address token,
uint liquidity,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline) external returns (uint amountToken, uint amountTRX);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityTRXWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountTRX);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactTRXForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactTRX(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForTRX(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapTRXForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IAVAX20 {
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);
}
interface IWAVAX {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
contract arb is Ownable{
using SafeMath for uint;
address private WAVAX = address(0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7);
fallback() external payable{
}
function swap(address[] memory path , address pair, uint256 amount, uint256 amount_outMin) external onlyOwner() {
(uint256 reserve0, uint256 reserve1,) = IUniswapV2Pair(pair).getReserves();
address token0 = IUniswapV2Pair(pair).token0();
address token1 = IUniswapV2Pair(pair).token1();
uint256 reserveIn = path[0] == token0 ? reserve0 : reserve1;
uint256 reserveOut = path[1] == token1 ? reserve1 : reserve0;
uint256 amountOut = calculate(amount, reserveIn, reserveOut);
(uint256 amount0Out, uint256 amount1Out) = path[0] == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
require(amountOut >= amount_outMin);
assert(IWAVAX(path[0]).transfer(pair, amount));
IUniswapV2Pair(pair).swap(amount0Out , amount1Out, address(this), new bytes(0));
}
event Received(address, uint);
receive() external payable {
emit Received(msg.sender, msg.value);
}
function withdrawAVAX() external onlyOwner() {
payable(msg.sender).transfer(address(this).balance);
}
function withdrawToken(uint256 amount , address token) external onlyOwner{
IAVAX20(token).transfer(msg.sender ,amount);
}
function calculate(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
uint amountInWithFee = amountIn.mul(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountOut(address[] memory path , address pair, uint256 amount) internal view returns (uint amountOut) {
}
}
| 86,095 | 12,855 |
af4b19e828d9b43faa06b2e738f5baf3c1b53c71a71461c4b8b052d08780764d
| 29,231 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/Lepricon-0x83efcc38f2e26f41e78eee821a3f56e53e722139.sol
| 3,396 | 12,613 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Lepricon is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 189,466 | 12,856 |
17f96cfe48de13a1629c78f30e9224e249223f3d02e47cd1acf6f8f9a5f30c0d
| 12,507 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/4f/4F025F5Ce0525bb6961f31e874d8B2B9DbB026D5_pStrudelERC20.sol
| 3,106 | 11,736 |
// 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;
// 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 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 substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
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_);
}
}
library Context {
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = Context._msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == Context._msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
uint8 internal _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view 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(Context._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(Context._msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, Context._msgSender(), _allowances[sender][Context._msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(Context._msgSender(), spender, _allowances[Context._msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(Context._msgSender(), spender, _allowances[Context._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 ammount_) internal virtual {
require(account_ != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(this), account_, ammount_);
_totalSupply = _totalSupply.add(ammount_);
_balances[account_] = _balances[account_].add(ammount_);
emit Transfer(address(this), account_, ammount_);
}
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 { }
}
abstract contract Divine is ERC20, Ownable {
constructor (string memory name_, string memory symbol_, uint8 decimals_) ERC20(name_, symbol_, decimals_) {}
}
contract pStrudelERC20 is Divine {
using SafeMath for uint256;
bool public requireSellerApproval;
bool public allowMinting;
mapping(address => bool) public isApprovedSeller;
constructor() Divine("pORKAN", "pORKAN", 18) {
uint256 initialSupply_ = 60 * 1000 * 1000 * 1e18; //writing out 60 million ether units the long way to be safe
requireSellerApproval = true;
allowMinting = true;
_addApprovedSeller(address(this));
_addApprovedSeller(msg.sender);
_mint(owner(), initialSupply_);
}
function allowOpenTrading() external onlyOwner() returns (bool) {
requireSellerApproval = false;
return requireSellerApproval;
}
function disableMinting() external onlyOwner() returns (bool) {
allowMinting = false;
return allowMinting;
}
function _addApprovedSeller(address approvedSeller_) internal {
isApprovedSeller[approvedSeller_] = true;
}
function addApprovedSeller(address approvedSeller_) external onlyOwner() returns (bool) {
_addApprovedSeller(approvedSeller_);
return isApprovedSeller[approvedSeller_];
}
function addApprovedSellers(address[] calldata approvedSellers_) external onlyOwner() returns (bool) {
for(uint256 iteration_; approvedSellers_.length > iteration_; iteration_++) {
_addApprovedSeller(approvedSellers_[iteration_]);
}
return true;
}
function _removeApprovedSeller(address disapprovedSeller_) internal {
isApprovedSeller[disapprovedSeller_] = false;
}
function removeApprovedSeller(address disapprovedSeller_) external onlyOwner() returns (bool) {
_removeApprovedSeller(disapprovedSeller_);
return isApprovedSeller[disapprovedSeller_];
}
function removeApprovedSellers(address[] calldata disapprovedSellers_) external onlyOwner() returns (bool) {
for(uint256 iteration_; disapprovedSellers_.length > iteration_; iteration_++) {
_removeApprovedSeller(disapprovedSellers_[iteration_]);
}
return true;
}
function _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal override {
require((_balances[to_] > 0 || isApprovedSeller[from_] == true), "Account not approved to transfer pORKAN.");
}
function mint(address recipient_, uint256 amount_) public virtual onlyOwner() {
require(allowMinting, "Minting has been disabled.");
_mint(recipient_, amount_);
}
function burn(uint256 amount_) public virtual {
_burn(msg.sender, amount_);
}
function burnFrom(address account_, uint256 amount_) public virtual {
_burnFrom(account_, amount_);
}
function _burnFrom(address account_, uint256 amount_) internal virtual {
uint256 decreasedAllowance_ = allowance(account_, msg.sender).sub(amount_, "ERC20: burn amount exceeds allowance");
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
}
| 324,247 | 12,857 |
a1409e763c258bea14a9848ffc3aba752f66be275b59c3313f4b8ebf30080ee0
| 9,899 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0xafedea9dba7d644572aa7c443198c65514faaef2.sol
| 2,398 | 9,576 |
pragma solidity 0.4.16;
// Used for function invoke restriction
contract Owned {
address public owner; // temporary address
function Owned() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner)
revert();
_; // function code inserted here
}
function transferOwnership(address _newOwner) onlyOwner returns (bool success) {
if (msg.sender != owner)
revert();
owner = _newOwner;
return true;
}
}
contract SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
require(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) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract CoinMarketAlert is Owned, SafeMath {
address[] public userAddresses;
uint256 public totalSupply;
uint256 public usersRegistered;
uint8 public decimals;
string public name;
string public symbol;
bool public tokenTransfersFrozen;
bool public tokenMintingEnabled;
bool public contractLaunched;
struct AlertCreatorStruct {
address alertCreator;
uint256 alertsCreated;
}
AlertCreatorStruct[] public alertCreators;
// Alert Creator Entered (Used to prevetnt duplicates in creator array)
mapping (address => bool) public userRegistered;
// Tracks approval
mapping (address => mapping (address => uint256)) public allowance;
//[addr][balance]
mapping (address => uint256) public balances;
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event Approve(address indexed _owner, address indexed _spender, uint256 _amount);
event MintTokens(address indexed _minter, uint256 _amountMinted, bool indexed Minted);
event FreezeTransfers(address indexed _freezer, bool indexed _frozen);
event ThawTransfers(address indexed _thawer, bool indexed _thawed);
event TokenBurn(address indexed _burner, uint256 _amount, bool indexed _burned);
event EnableTokenMinting(bool Enabled);
function CoinMarketAlert() {
symbol = "CMA";
name = "Coin Market Alert";
decimals = 18;
// 50 Mil in wei
totalSupply = 50000000000000000000000000;
balances[msg.sender] = add(balances[msg.sender], totalSupply);
tokenTransfersFrozen = true;
tokenMintingEnabled = false;
}
/// @notice Used to launch start the contract
function launchContract() onlyOwner returns (bool launched) {
require(!contractLaunched);
tokenTransfersFrozen = false;
tokenMintingEnabled = true;
contractLaunched = true;
EnableTokenMinting(true);
return true;
}
/// @dev keeps a list of addresses that are participating in the site
function registerUser(address _user) private returns (bool registered) {
usersRegistered = add(usersRegistered, 1);
AlertCreatorStruct memory acs;
acs.alertCreator = _user;
alertCreators.push(acs);
userAddresses.push(_user);
userRegistered[_user] = true;
return true;
}
/// @notice Manual payout for site users
/// @param _user Ethereum address of the user
/// @param _amount The mount of CMA tokens in wei to send
function singlePayout(address _user, uint256 _amount) onlyOwner returns (bool paid) {
require(!tokenTransfersFrozen);
require(_amount > 0);
require(transferCheck(owner, _user, _amount));
if (!userRegistered[_user]) {
registerUser(_user);
}
balances[_user] = add(balances[_user], _amount);
balances[owner] = sub(balances[owner], _amount);
Transfer(owner, _user, _amount);
return true;
}
/// @dev low-level minting function not accessible externally
function tokenMint(address _invoker, uint256 _amount) private returns (bool raised) {
require(add(balances[owner], _amount) > balances[owner]);
require(add(balances[owner], _amount) > 0);
require(add(totalSupply, _amount) > 0);
require(add(totalSupply, _amount) > totalSupply);
totalSupply = add(totalSupply, _amount);
balances[owner] = add(balances[owner], _amount);
MintTokens(_invoker, _amount, true);
return true;
}
/// @notice Used to mint tokens, only usable by the contract owner
/// @param _amount The amount of CMA tokens in wei to mint
function tokenFactory(uint256 _amount) onlyOwner returns (bool success) {
require(_amount > 0);
require(tokenMintingEnabled);
if (!tokenMint(msg.sender, _amount))
revert();
return true;
}
/// @notice Used to burn tokens
/// @param _amount The amount of CMA tokens in wei to burn
function tokenBurn(uint256 _amount) onlyOwner returns (bool burned) {
require(_amount > 0);
require(_amount < totalSupply);
require(balances[owner] > _amount);
require(sub(balances[owner], _amount) > 0);
require(sub(totalSupply, _amount) > 0);
balances[owner] = sub(balances[owner], _amount);
totalSupply = sub(totalSupply, _amount);
TokenBurn(msg.sender, _amount, true);
return true;
}
/// @notice Used to freeze token transfers
function freezeTransfers() onlyOwner returns (bool frozen) {
tokenTransfersFrozen = true;
FreezeTransfers(msg.sender, true);
return true;
}
/// @notice Used to thaw token transfers
function thawTransfers() onlyOwner returns (bool thawed) {
tokenTransfersFrozen = false;
ThawTransfers(msg.sender, true);
return true;
}
/// @notice Used to transfer funds
/// @param _receiver The destination ethereum address
/// @param _amount The amount of CMA tokens in wei to send
function transfer(address _receiver, uint256 _amount) {
require(!tokenTransfersFrozen);
if (transferCheck(msg.sender, _receiver, _amount)) {
balances[msg.sender] = sub(balances[msg.sender], _amount);
balances[_receiver] = add(balances[_receiver], _amount);
Transfer(msg.sender, _receiver, _amount);
} else {
// ensure we refund gas costs
revert();
}
}
/// @notice Used to transfer funds on behalf of one person
/// @param _owner Person you are allowed to spend funds on behalf of
/// @param _receiver Person to receive the funds
/// @param _amount Amoun of CMA tokens in wei to send
function transferFrom(address _owner, address _receiver, uint256 _amount) {
require(!tokenTransfersFrozen);
require(sub(allowance[_owner][msg.sender], _amount) >= 0);
if (transferCheck(_owner, _receiver, _amount)) {
balances[_owner] = sub(balances[_owner], _amount);
balances[_receiver] = add(balances[_receiver], _amount);
allowance[_owner][_receiver] = sub(allowance[_owner][_receiver], _amount);
Transfer(_owner, _receiver, _amount);
} else {
// ensure we refund gas costs
revert();
}
}
/// @notice Used to approve a third-party to send funds on your behalf
/// @param _spender The person you are allowing to spend on your behalf
/// @param _amount The amount of CMA tokens in wei they are allowed to spend
function approve(address _spender, uint256 _amount) returns (bool approved) {
require(_amount > 0);
require(balances[msg.sender] > 0);
allowance[msg.sender][_spender] = _amount;
Approve(msg.sender, _spender, _amount);
return true;
}
//GETTERS//
///////////
/// @dev low level function used to do a sanity check of input data for CMA token transfers
/// @param _sender This is the msg.sender, the person sending the CMA tokens
/// @param _receiver This is the address receiving the CMA tokens
/// @param _value This is the amount of CMA tokens in wei to send
function transferCheck(address _sender, address _receiver, uint256 _value)
private
constant
returns (bool safe)
{
require(_value > 0);
// prevents empty receiver
require(_receiver != address(0));
require(sub(balances[_sender], _value) >= 0);
require(add(balances[_receiver], _value) > balances[_receiver]);
return true;
}
/// @notice Used to retrieve total supply
function totalSupply() constant returns (uint256 _totalSupply) {
return totalSupply;
}
/// @notice Used to look up balance of a user
function balanceOf(address _person) constant returns (uint256 balance) {
return balances[_person];
}
/// @notice Used to look up allowance of a user
function allowance(address _owner, address _spender) constant returns (uint256 allowed) {
return allowance[_owner][_spender];
}
}
| 133,534 | 12,858 |
dcdfb344793ff50b6c02217f85934d2b7b5a6ff77d0a1f464e40403b33ca4cde
| 11,125 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYuRvruZpZnJBugvZxGJ9VBJmZs2dKZUFG_GooseBetToken.sol
| 2,689 | 10,171 |
//SourceUnit: GBT.sol
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 GooseBetToken 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 = "GooseBetToken";
string public constant symbol = "GBT";
uint public constant decimals = 6;
uint public deadline = now + 0 * 1 seconds; //Now
uint public round2 = now + 50 * 1 days;
uint public round1 = now + 10 * 1 days;
uint256 public totalSupply = 200000000e6;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1000 ; //
uint256 public tokensPerEth =1e6; // Last updated price by admin
uint public target0drop = 0e6; //No
uint public progress0drop = 0;
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 companyFund = 200000000e6; // 0
owner = msg.sender;
distr(owner, companyFund);
}
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 = 10000 / 2; // Send 100000 trx or more and get 2% more GBT of round 1
uint256 bonusCond2 = 10000 / 1; // Send 100000 trx or more and get 1% more GBT of round 2
uint256 bonusCond3 = 10000 ;
tokens = tokensPerEth.mul(msg.value) / 1000 ;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 2 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 0 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 2 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 0.0001e6;
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;
}
}
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);
}
}
| 302,653 | 12,859 |
31532c70a49f6e7396dcbc814ceb3754277d03262b582db4fcc06c07b7da545d
| 29,468 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x693b9f297Ba83E89a73Ec8a1AA28035165108C97/contract.sol
| 3,393 | 12,614 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract QUANTDEFI is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 248,729 | 12,860 |
8e4bc6552d4f0c4542271d0f5a1b06ad8c0d66e3a9771244e01be9857e97ddd7
| 18,822 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/5b/5bDd1a9ec1DC8F67Bdb45c166a236380fd3cC1F0_BIGFTM.sol
| 4,186 | 15,792 |
// 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 BIGFTM 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 = 'BIGFTM';
string private _symbol = 'BIGFTM';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(5);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 333,434 | 12,861 |
d048944e5931d069985baea1a8d8b9b15ed432a887223d1cbb4dd08c010be28b
| 12,226 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/cf/CfD5a47a6e4a3C84C8D9C7757F2ca0b840F6D24B_MultiAVAX.sol
| 3,615 | 10,762 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract MultiAVAX {
using SafeMath for uint256;
string public name = "MultiAVAX";
uint256 constant public INVEST_MIN_AMOUNT = 0.01 ether;
uint256[] public REFERRAL_PERCENTS = [50, 25, 5];
uint256 constant public PROJECT_FEE = 100;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public MAXIMUM_NUMBER_DEPOSITS = 100;
uint256 public totalStaked;
uint256 public totalUsers;
struct Plan {
uint256 time;
uint256 percent;
uint256 tax;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
uint256 tax;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256[3] levels;
uint256 bonus;
uint256 totalBonus;
}
mapping (address => User) internal users;
address payable public devWallet;
address payable public operationalAccount;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address _devWallet, address _operationalAccount) {
devWallet = payable(_devWallet);
operationalAccount = payable(_operationalAccount);
plans.push(Plan(14, 70, 100));
plans.push(Plan(21, 77, 150));
plans.push(Plan(28, 87, 200));
}
function invest(address referrer, uint8 plan) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
require(plan < 3, "Invalid plan");
User storage user = users[msg.sender];
require(user.deposits.length < MAXIMUM_NUMBER_DEPOSITS, "Maximum number of deposits reached.");
uint256 fees = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
(uint256 devFee, uint256 operatingFee) = getFeeAllocation(fees);
devWallet.transfer(devFee);
operationalAccount.transfer(operatingFee);
emit FeePayed(msg.sender, fees);
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
(uint256 percent, uint256 profit, uint256 finish, uint256 tax) = getResult(plan, msg.value);
user.deposits.push(Deposit(plan, percent, msg.value, profit, block.timestamp, finish, tax));
totalStaked = totalStaked.add(msg.value);
emit NewDeposit(msg.sender, plan, percent, msg.value, profit, block.timestamp, finish);
}
function getFeeAllocation(uint256 fees) public view returns (uint256 devFee, uint256 operatingFee) {
if(totalStaked < 400000 ether) {
devFee = fees.mul(300).div(PERCENTS_DIVIDER);
operatingFee = fees.mul(700).div(PERCENTS_DIVIDER);
}
else {
devFee = fees.mul(500).div(PERCENTS_DIVIDER);
operatingFee = fees.mul(500).div(PERCENTS_DIVIDER);
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 tax;
for (uint256 i = 0; i < capped(user.deposits.length); i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (block.timestamp > user.deposits[i].finish) {
tax = tax.add(user.deposits[i].profit.mul(user.deposits[i].tax).div(PERCENTS_DIVIDER));
}
}
}
totalAmount = totalAmount.sub(tax);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
address payable sender = payable(msg.sender);
sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function snoozeAll(uint256 _days) public {
require(_days > 0, "Invalid argument _days (min 1).");
require(_days < 8, "Invalid argument _days (max 7).");
User storage user = users[msg.sender];
uint256 count;
for (uint256 i = 0; i < capped(user.deposits.length); i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (block.timestamp > user.deposits[i].finish) {
count = count.add(1);
snooze(msg.sender, i, _days);
}
}
}
require(count > 0, "No plans are currently eligible");
}
function snoozeAt(uint256 index, uint256 _days) public {
require(_days > 0, "Invalid argument _days (min 1).");
require(_days < 8, "invalid argument _days (max 7).");
snooze(msg.sender, index, _days);
}
function snooze(address sender, uint256 index, uint256 _days) private {
User storage user = users[sender];
require(index < user.deposits.length, "Deposit at index does not exist");
require(user.checkpoint < user.deposits[index].finish, "Deposit term already paid out.");
require(block.timestamp > user.deposits[index].finish, "Deposit term is not completed.");
uint8 plan = user.deposits[index].plan;
uint256 percent = getPercent(plan);
uint256 basis = user.deposits[index].profit;
uint256 profit;
for (uint256 i = 0; i < _days; i++) {
profit = profit.add((basis.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
user.deposits[index].profit = user.deposits[index].profit.add(profit);
user.deposits[index].finish = user.deposits[index].finish.add(_days.mul(TIME_STEP));
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < capped(user.deposits.length); i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
return totalAmount;
}
function capped(uint256 length) public pure returns (uint256 cap) {
if(length < MAXIMUM_NUMBER_DEPOSITS) {
cap = length;
} else {
cap = MAXIMUM_NUMBER_DEPOSITS;
}
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish, uint256 tax) {
percent = getPercent(plan);
tax = getTax(plan);
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
return plans[plan].percent;
}
function getTax(uint8 plan) public view returns (uint256) {
return plans[plan].tax;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2]);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish, uint256 tax) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
tax = user.deposits[index].tax;
}
function getUserDeposits(address userAddress) public view returns(Deposit[] memory deposits) {
return users[userAddress].deposits;
}
}
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;
}
}
| 97,891 | 12,862 |
91ac054af2c503a4df40dcd0dbfcb098c8cf1fb0987bf3773081c40a6192ee27
| 29,656 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/88/888d478f3a26216b0d79bad47daf39c7018b0888_SimplePools.sol
| 3,999 | 15,842 |
pragma solidity ^0.8.17;
// SPDX-License-Identifier: MIT
contract SimplePools {
struct Pool {
uint256 poolId;
IERC20 token1;
IERC20 token2;
uint256 token1Amount;
uint256 token2Amount;
uint256 token2VirtualAmount;
uint8 maxBuyToken1PercentPerTransaction;
uint256 constantProduct; // (T1*(T2+VT2))=ConstantProduct
bool isConstantPrice;
uint256 initialToken1Amount;
address poolOwner;
bool isLocked;
bool isEmpty;
}
Pool[] public _pools;
uint256[] _allTransactionsPoolIds;
constructor() {}
function createPool(IERC20 token1,
IERC20 token2,
uint256 token1Amount,
uint256 matchingPriceInToken2,
uint8 maxBuyToken1PercentPerTransaction,
bool isConstantPrice) external {
require(token1 != token2, "tokens must be different");
uint poolId = _pools.length;
_allTransactionsPoolIds.push(poolId);
token1.transferFrom(msg.sender, address(this), token1Amount);
_pools.push().poolId = poolId;
_pools[poolId].token1 = token1;
_pools[poolId].token2 = token2;
_pools[poolId].token1Amount = token1Amount;
_pools[poolId].token2Amount = 0;
_pools[poolId].token2VirtualAmount = matchingPriceInToken2;
_pools[poolId].maxBuyToken1PercentPerTransaction = maxBuyToken1PercentPerTransaction;
_pools[poolId].constantProduct = token1Amount * matchingPriceInToken2;
_pools[poolId].isConstantPrice = isConstantPrice;
_pools[poolId].initialToken1Amount = token1Amount;
_pools[poolId].poolOwner = msg.sender;
_pools[poolId].isLocked = false;
_pools[poolId].isEmpty = false;
}
function exchangeToken(IERC20 tokenToBuy,
uint256 poolId,
uint256 tokenToSellAmount,
uint256 minReceiveTokenToBuyAmount) external returns (uint256) {
require(!_pools[poolId].isEmpty, "Pool is empty");
Pool storage pool = _pools[poolId];
require(tokenToBuy == pool.token1 || tokenToBuy == pool.token2, "trying to buy from wrong pool");
_allTransactionsPoolIds.push(poolId);
if (tokenToBuy == pool.token1) {
uint amountOut;
if (pool.isConstantPrice) {
amountOut = Math.mulDiv(tokenToSellAmount, pool.initialToken1Amount, pool.token2VirtualAmount);
} else {
amountOut = pool.token1Amount -
Math.ceilDiv(pool.constantProduct,
pool.token2VirtualAmount + pool.token2Amount + tokenToSellAmount);
}
amountOut = Math.min(amountOut, Math.mulDiv(pool.token1Amount, pool.maxBuyToken1PercentPerTransaction, 100));
require(pool.token2.allowance(msg.sender, address(this)) >= tokenToSellAmount, "trying to sell more than allowance");
require(minReceiveTokenToBuyAmount <= amountOut,"minReceive is less than calcualted amount");
// complete the transaction now
require(pool.token2.transferFrom(msg.sender, address(this), tokenToSellAmount), "cannot transfer tokenToSellAmount");
pool.token2Amount += tokenToSellAmount;
require(pool.token1.transfer(msg.sender, amountOut), "cannot transfer from amountOut from pool");
pool.token1Amount -= amountOut;
pool.constantProduct = (pool.token1Amount) * (pool.token2Amount + pool.token2VirtualAmount);
return amountOut;
} else if (tokenToBuy == pool.token2) {
require(pool.token2Amount > 0, "zero amount of token for buy in pool");
uint amountOut;
if (pool.isConstantPrice) {
amountOut = Math.mulDiv(tokenToSellAmount, pool.token2VirtualAmount, pool.initialToken1Amount);
} else {
amountOut = pool.token2VirtualAmount + pool.token2Amount
- Math.ceilDiv(pool.constantProduct,
pool.token1Amount + tokenToSellAmount);
}
amountOut = Math.min(amountOut, pool.token2Amount);
require(pool.token1.allowance(msg.sender, address(this)) >= tokenToSellAmount, "trying to sell more than allowance");
require(minReceiveTokenToBuyAmount <= amountOut,"minReceive is more than calcualted amount");
// complete the transaction now
require(pool.token1.transferFrom(msg.sender, address(this), tokenToSellAmount), "cannot transfer tokenToSellAmount");
pool.token1Amount += tokenToSellAmount;
require(pool.token2.transfer(msg.sender, amountOut), "cannot transfer from amountOut from pool");
pool.token2Amount -= amountOut;
pool.constantProduct = (pool.token1Amount) * (pool.token2Amount + pool.token2VirtualAmount);
return amountOut;
}
require(false, "Wrong token address or poolId");
return 0;
}
function getAllTokensFromPool(uint256 poolId) external {
require(_pools.length > poolId, "invalid pool id");
require(!_pools[poolId].isLocked, "pool is locked");
require(!_pools[poolId].isEmpty, "pool is empty");
require(_pools[poolId].poolOwner == msg.sender, "only the pool owner can empty pool");
_allTransactionsPoolIds.push(poolId);
Pool storage pool = _pools[poolId];
pool.token1.transferFrom(address(this), msg.sender, pool.token1Amount);
pool.token1Amount = 0;
pool.token2.transferFrom(address(this), msg.sender, pool.token2Amount);
pool.token2Amount = 0;
pool.token2VirtualAmount = 0;
pool.isEmpty = true;
}
function lockPool(uint256 poolId) external returns (bool) {
require(_pools.length > poolId, "invalid pool id");
require(!_pools[poolId].isLocked, "pool is already locked");
require(_pools[poolId].poolOwner == msg.sender, "only the pool owner can lock a pool");
_allTransactionsPoolIds.push(poolId);
_pools[poolId].isLocked = true;
return true;
}
function changeOwner(uint256 poolId,
address newPoolOwner) external returns (bool) {
require(poolId < _pools.length, "invalid poolId");
require(!_pools[poolId].isLocked, "pool is locked");
require(_pools[poolId].poolOwner == msg.sender, "only the pool owner can change ownership");
_pools[poolId].poolOwner = newPoolOwner;
_allTransactionsPoolIds.push(poolId);
return true;
}
function changePoolMaxBuyToken1PercentPerTransaction(uint256 poolId,
uint8 newMaxBuyToken1PercentPerTransaction) external returns (bool) {
require(poolId < _pools.length, "invalid poolId");
require(!_pools[poolId].isLocked, "pool is locked");
require(_pools[poolId].poolOwner == msg.sender,
"only the pool owner can change newMaxBuyToken1PercentPerTransaction");
require(newMaxBuyToken1PercentPerTransaction <= 100 &&
newMaxBuyToken1PercentPerTransaction > 0,
"invalid max percent per transaction");
_pools[poolId].maxBuyToken1PercentPerTransaction = newMaxBuyToken1PercentPerTransaction;
_allTransactionsPoolIds.push(poolId);
return true;
}
function changeContantProduct(uint256 poolId,
uint256 newConstantProduct) external returns (bool) {
require(poolId < _pools.length, "invalid poolId");
require(!_pools[poolId].isLocked, "pool is locked");
require(_pools[poolId].poolOwner == msg.sender, "only the pool owner can change the constant product");
require(newConstantProduct > 0, "invalid constant product (only positive numbers)");
_pools[poolId].constantProduct = newConstantProduct;
_allTransactionsPoolIds.push(poolId);
return true;
}
function isPoolLocked(uint256 poolId) external view returns (bool) {
return _pools[poolId].isLocked;
}
function getPoolsCount() external view returns (uint) {
return _pools.length;
}
function getPools(uint256 startPoolIndex,
uint256 endPoolIndex) external view returns (Pool[] memory) {
require(endPoolIndex > startPoolIndex && endPoolIndex <= _pools.length, "invalid indexes");
Pool[] memory pools = new Pool[](endPoolIndex - startPoolIndex);
for (uint i = startPoolIndex; i < endPoolIndex; ++i) {
pools[i - startPoolIndex] = _pools[i];
}
return pools;
}
function getPoolsFrom(uint256 startPoolIndex) external view returns (Pool[] memory) {
require(startPoolIndex < _pools.length, "invalid index");
Pool[] memory pools = new Pool[](_pools.length - startPoolIndex);
for (uint i = startPoolIndex; i < _pools.length; ++i) {
pools[i - startPoolIndex] = _pools[i];
}
return pools;
}
function getPools(uint256[] memory indexes) external view returns (Pool[] memory) {
Pool[] memory pools = new Pool[](indexes.length);
for (uint256 i = 0; i < indexes.length; ++i) {
Pool storage pool = _pools[indexes[i]];
pools[i] = pool;
}
return pools;
}
function getPool(uint256 poolId) external view returns (Pool memory) {
return _pools[poolId];
}
function getTransactionsCount() external view returns (uint256) {
return _allTransactionsPoolIds.length;
}
function getPoolsForTransactionsWithIndexesBetween(uint256 startTransactionIndex,
uint256 endTransactionIndex) external view returns (uint256[] memory) {
require(endTransactionIndex > startTransactionIndex &&
endTransactionIndex <= _allTransactionsPoolIds.length, "invalid indexes");
uint[] memory poolIndexes = new uint[](endTransactionIndex - startTransactionIndex);
for (uint i = startTransactionIndex; i < endTransactionIndex; ++i) {
poolIndexes[i - startTransactionIndex] = _allTransactionsPoolIds[i];
}
return poolIndexes;
}
function getPoolsForTransactionsWithIndexesFrom(uint startTransactionIndex) external view returns (uint[] memory) {
require(startTransactionIndex < _allTransactionsPoolIds.length, "invalid index");
uint[] memory poolIndexes = new uint[](_allTransactionsPoolIds.length - startTransactionIndex);
for (uint i = startTransactionIndex; i < _allTransactionsPoolIds.length; ++i) {
poolIndexes[i - startTransactionIndex] = _allTransactionsPoolIds[i];
}
return poolIndexes;
}
function getTokenName(IERC20 token) external view returns (string memory) {
return token.name();
}
function getTokenSymbol(IERC20 token) external view returns (string memory) {
return token.symbol();
}
function getTokenDecimals(IERC20 token) external view returns (uint8) {
return token.decimals();
}
function getTokenTotalSupply(IERC20 token) external view returns (uint256) {
return token.totalSupply();
}
function getTokenTotalAllowance(IERC20 token, address owner, address spender) external view returns (uint256) {
return token.allowance(owner, spender);
}
}
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x,
uint256 y,
uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1);
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// is no longer required.
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
| 317,638 | 12,863 |
bebc470b9ae59d55125d730bd4bec53bcf505f79961b962cbf04ad26f21477bb
| 28,956 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xc5eACE3f47869e9E939cF307C656852E8EfaC2aD/contract.sol
| 5,095 | 18,258 |
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 PASTA 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;
uint8 private constant _decimals = 8;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 36000000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'PASTA';
string private constant _symbol = 'PASTA';
uint256 private _taxFee = 180;
uint256 private _burnFee = 180;
uint private _max_tx_size = 360000 * 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, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _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;
}
}
| 256,470 | 12,864 |
741439c8dec11df8f21863bddcd0a39067b6fcb43d488147724525bf49d9fa5d
| 15,511 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x0520959c7b38a2db9f9ed0f7b0fc621cf22c07a0.sol
| 2,627 | 9,615 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract 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);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract 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 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 PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract CappedToken is MintableToken {
uint256 public cap;
function CappedToken(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
}
}
contract CommunityCoin is CappedToken, PausableToken {
using SafeMath for uint;
string public constant symbol = "CTC";
string public constant name = "Coin of The Community";
uint8 public constant decimals = 18;
uint public constant unit = 10 ** uint256(decimals);
uint public lockPeriod = 90 days;
uint public startTime;
function CommunityCoin(uint _startTime,uint _tokenCap) CappedToken(_tokenCap.mul(unit)) public {
totalSupply_ = 0;
startTime=_startTime;
pause();
}
function unpause() onlyOwner whenPaused public {
require(now > startTime + lockPeriod);
super.unpause();
}
function setLockPeriod(uint _period) onlyOwner public {
lockPeriod = _period;
}
function () payable public {
revert();
}
}
contract TokenLocker is Ownable, ERC20Basic {
using SafeERC20 for CommunityCoin;
using SafeMath for uint;
CommunityCoin public token;
string public constant symbol = "CTCX";
string public constant name = "CTC(locked)";
uint8 public constant decimals = 18;
mapping(address => uint) balances;
uint private pool;
uint public releaseTime;
uint constant public lockPeriod = 180 days;
event TokenReleased(address _to, uint _value);
function TokenLocker(CommunityCoin _token) public {
token = _token;
releaseTime = token.startTime().add(lockPeriod);
}
function totalSupply() view public returns(uint){
return pool;
}
function balanceOf(address _who) view public returns(uint balance) {
return balances[_who];
}
function deposite() public onlyOwner {
uint newPool = token.balanceOf(this);
require(newPool > pool);
uint amount = newPool.sub(pool);
pool = newPool;
balances[owner] = balances[owner].add(amount);
Transfer(address(0), owner, amount);
}
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 release() public {
require(now >= releaseTime);
uint amount = balances[msg.sender];
require(amount > 0);
require(pool >= amount);
balances[msg.sender] = 0;
pool = pool.sub(amount);
token.safeTransfer(msg.sender,amount);
Transfer(msg.sender,address(0), amount);
TokenReleased(msg.sender,amount);
}
function setToken(address tokenAddress) onlyOwner public {
token = CommunityCoin(tokenAddress);
}
function setReleaseTime(uint _time) onlyOwner public {
releaseTime = _time;
}
function () payable public{
revert();
}
}
| 210,596 | 12,865 |
a67962d8008974dc96d2439eb7c9078993fc4094bc59b1cad9100fc7ecb0f25b
| 16,795 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Gambling/0x2A1e5f02FC82f6Ac2ABefA2cfBB67E59cEe987b5.sol
| 3,946 | 14,643 |
pragma solidity 0.5.8;
contract SmartLotto {
uint private constant TICKET_PRICE = 0.01 ether;
uint8 private constant REQ_NUMBERS = 5;
uint8 private constant MAX_NUMBER = 36;
uint8 private constant MIN_WIN_MATCH = 2;
uint8 private constant ARR_SIZE = REQ_NUMBERS - MIN_WIN_MATCH + 1;
uint8 private constant DRAW_DOW = 2;
uint private constant DRAW_HOUR = 16 hours;
uint private constant BEF_PERIOD = 60 minutes;
uint private constant AFT_PERIOD = 60 minutes;
uint8 private constant PERCENT_FUND_PR = 20;
uint8[ARR_SIZE] private PERCENT_FUNDS = [20, 30, 35, 15];
// Controll addresses
address private constant CONTROL = 0x203bF6B46508eD917c085F50F194F36b0a62EB02;
address payable private constant PR = 0xCD66911b6f38FaAF5BFeE427b3Ceb7D18Dd09F78;
address payable private constant ADMIN_JACKPOT = 0x531d3Bd0400Ae601f26B335EfbD787415Aa5CB81;
uint private constant ACTIVITY_PERIOD = 20 weeks;
uint private constant POOL_SIZE = 50;
struct Member {
address payable addr;
uint8[REQ_NUMBERS] numbers;
uint8 matchNumbers;
uint prize;
}
struct Game {
uint membersCounter;
uint winnersCounter;
uint8[REQ_NUMBERS] winNumbers;
uint totalFund;
uint[ARR_SIZE] funds;
uint[ARR_SIZE] winners;
uint8 status;
mapping(uint => Member) members;
mapping(uint => uint) winTickets;
}
uint8 private contractStatus = 1;
uint private gameNum = 1;
mapping(uint => Game) private games;
uint private firstActivityTime = 0;
uint private lastActivityTime = 0;
uint private adminJackpotAmount = 0;
uint private poolCounter = 0;
uint private controlPhase = 0;
// _action: 0 - New game, 1 - Change status (Drawing), 2 - Jackpot change
event GameChanged(uint _gameNum, uint8 _action);
event MemberChanged(uint _gameNum, uint _member, uint _prize);
// For any status
function getGameInfo(uint gamenum) public view returns
(uint _gamenum, uint _membersCounter, uint _totalFund, uint8 _status) {
if (gamenum == 0) gamenum = gameNum;
return (gamenum, games[gamenum].membersCounter, games[gamenum].totalFund, games[gamenum].status);
}
// For any status
function getGameFunds(uint gamenum) public view returns (uint[ARR_SIZE] memory _funds) {
if (games[gamenum].status > 0)
_funds = games[gamenum].funds;
else
_funds = calcGameFunds();
return _funds;
}
// For status > 0
function getGameWinNumbers(uint gamenum) public view returns (uint8[REQ_NUMBERS] memory _winNumbers) {
return games[gamenum].winNumbers;
}
// For status == 2
function getGameWinners(uint gamenum) public view returns (uint[ARR_SIZE] memory _winners) {
return games[gamenum].winners;
}
function getMemberInfo(uint gamenum, uint member) public view returns
(address _addr, uint _prize, uint8[REQ_NUMBERS] memory _numbers) {
Member memory mbr = games[gamenum].members[member];
return (mbr.addr, mbr.prize, mbr.numbers);
}
// ENTRY POINT
function() external payable {
// Check contract status
require(contractStatus == 1, "Contract closed.");
// CONTROL
if (msg.sender == CONTROL) {
doControl();
return;
}
// For admin & user game status must be 0
require(games[gameNum].status == 0, "The game is drawing, try again later.");
// ADMIN JACKPOT
if (msg.sender == ADMIN_JACKPOT) {
doAdminJackpot();
return;
}
// USER
uint8 weekday = getWeekday(now);
uint nowMinute = getDayMinute(now);
bool isDrawTime = (weekday == DRAW_DOW && (nowMinute > (DRAW_HOUR - BEF_PERIOD) / 60) && (nowMinute < (DRAW_HOUR + AFT_PERIOD) / 60));
require(!isDrawTime, "The game is drawing, try again later.");
require(msg.value == TICKET_PRICE, "Value must be '0.01' for play.");
doUser();
}
// Admin Jackpot process
function doAdminJackpot() private {
// If value > 0, increase admin jackpot and jackpot for current game
if (msg.value > 0) {
adminJackpotAmount += msg.value;
games[gameNum].funds[ARR_SIZE - 1] += msg.value; // Increase last funds elem
emit GameChanged(gameNum, 2);
return;
}
returnAdminJackpot();
}
// Return admin jackpot after ACTIVITY PERIOD
function returnAdminJackpot() private {
// Requires
require(adminJackpotAmount > 0,
"Admin Jackpot amount must be greater than 0.");
uint gameJackpotAmount = games[gameNum].funds[ARR_SIZE - 1];
require(gameJackpotAmount > adminJackpotAmount * 2 || (now - firstActivityTime) > ACTIVITY_PERIOD,
"Jackpot return is not currently available.");
if (gameJackpotAmount > adminJackpotAmount) {
ADMIN_JACKPOT.transfer(adminJackpotAmount);
games[gameNum].funds[ARR_SIZE - 1] -= adminJackpotAmount;
} else {
ADMIN_JACKPOT.transfer(gameJackpotAmount);
games[gameNum].funds[ARR_SIZE - 1] = 0;
}
adminJackpotAmount = 0;
emit GameChanged(gameNum, 2);
}
// Control process
function doControl() private {
require(msg.value == 0, "Control value must be 0.");
// First time check contract activity and generate winning numbers
if (games[gameNum].status == 0) {
// Check contract activity
checkContractActivity();
if (contractStatus == 0) return;
// Change game status to "Draw"
games[gameNum].status = 1;
// Generate winning numbers
games[gameNum].winNumbers = generateNumbers();
// Transfer PR fund
uint fundPR = games[gameNum].totalFund * PERCENT_FUND_PR / 100;
PR.transfer(fundPR);
// Calculate game funds
games[gameNum].funds = calcGameFunds();
emit GameChanged(gameNum, 1);
// Set control phase to 0 (Calculate)
controlPhase = 0;
// Reset pool counter to 0
poolCounter = 0;
}
if (controlPhase == 0) {
doCalculate();
} else {
doPayout();
}
}
function doCalculate() private {
// Process members list (calculate every match winners)
uint index;
uint8 mn;
uint8[ARR_SIZE] memory _w;
uint start = POOL_SIZE * poolCounter + 1;
uint end = POOL_SIZE * poolCounter + POOL_SIZE;
if (end > games[gameNum].membersCounter) end = games[gameNum].membersCounter;
// Calulate winners for pool
for (uint i = start; i <= end; i++) {
mn = findMatch(games[gameNum].winNumbers, games[gameNum].members[i].numbers);
// Change ticket match numbers
if (mn > 0)
games[gameNum].members[i].matchNumbers = mn;
// If ticket win prize
if (mn >= MIN_WIN_MATCH) {
_w[mn - MIN_WIN_MATCH]++;
games[gameNum].winnersCounter++;
index = games[gameNum].winnersCounter;
games[gameNum].winTickets[index] = i;
}
}
// Icrease game winners count
for (uint8 i = 0; i < ARR_SIZE; i++)
if (_w[i] != 0)
games[gameNum].winners[i] += _w[i];
// If last pool
if (end == games[gameNum].membersCounter) {
// If not exist matches 2/5, 3/5 etc, increase game jackpot on fund2, fund3 etc
for (uint8 i = 0; i < ARR_SIZE - 1; i++) {
if (games[gameNum].winners[i] == 0)
games[gameNum].funds[ARR_SIZE - 1] += games[gameNum].funds[i];
}
// Check and transit Jackpot
if (games[gameNum].winners[ARR_SIZE - 1] != 0) {
adminJackpotAmount = 0;
} else {
games[gameNum + 1].funds[ARR_SIZE - 1] = games[gameNum].funds[ARR_SIZE - 1];
}
// Set control phase to 1 (Payout) and reset poolCounter to 0
controlPhase = 1;
poolCounter = 0;
} else {
poolCounter++;
}
}
function doPayout() private {
// Process winning tickets list and payout prize
uint winTicket;
uint prize;
uint8 mn;
uint start = POOL_SIZE * poolCounter + 1;
uint end = POOL_SIZE * poolCounter + POOL_SIZE;
if (end > games[gameNum].winnersCounter) end = games[gameNum].winnersCounter;
// Loop winning tickets and payout RRR
for (uint i = start; i <= end; i++) {
winTicket = games[gameNum].winTickets[i];
mn = games[gameNum].members[winTicket].matchNumbers;
prize = games[gameNum].funds[mn - MIN_WIN_MATCH] / games[gameNum].winners[mn - MIN_WIN_MATCH];
games[gameNum].members[winTicket].prize = prize;
games[gameNum].members[winTicket].addr.transfer(prize);
emit MemberChanged(gameNum, i, prize);
}
if (end == games[gameNum].winnersCounter) {
// Change game status on "Closed"
games[gameNum].status = 2;
// Init Next Game
gameNum++;
emit GameChanged(gameNum, 0);
} else {
poolCounter++;
}
}
// Check contract activity
function checkContractActivity() private {
uint balance = address(this).balance;
// Set last activity
if (games[gameNum].membersCounter > 0) {
lastActivityTime = now;
}
// Check last activity
if (now - lastActivityTime > ACTIVITY_PERIOD) {
PR.transfer(balance);
contractStatus = 0;
games[gameNum].funds[ARR_SIZE - 1] = 0;
}
}
// User process
function doUser() private {
// First activity & last activity
if (firstActivityTime == 0) {
firstActivityTime = now;
lastActivityTime = now;
}
doTicket();
}
// Ticket process
function doTicket() private {
bool err = false;
uint8[REQ_NUMBERS] memory numbers;
// Parse and check msg.DATA
(err, numbers) = parseCheckData();
uint mbrCnt;
// If error DATA, generate random ticket numbers
if (err) {
numbers = generateNumbers();
} else {
numbers = sortNumbers(numbers);
}
// Increase member counter and total fund
games[gameNum].membersCounter++;
games[gameNum].totalFund += msg.value;
// Store member
mbrCnt = games[gameNum].membersCounter;
games[gameNum].members[mbrCnt].addr = msg.sender;
games[gameNum].members[mbrCnt].numbers = numbers;
emit MemberChanged(gameNum, mbrCnt, 0);
}
// Get timestamp minute of day
function getDayMinute(uint timestamp) private pure returns (uint) {
return ((timestamp / 60) % 1440);
}
// Get timestamp day of week
function getWeekday(uint timestamp) private pure returns (uint8) {
return uint8((timestamp / 86400 + 4) % 7);
}
// Generate random number
function random(uint8 num) internal view returns (uint8) {
return uint8((uint(blockhash(block.number - 1 - num*2)) + now) % MAX_NUMBER + 1);
}
// Generate winning numbers
function generateNumbers() private view returns (uint8[REQ_NUMBERS] memory numbers) {
// Generate random numbers
for (uint8 i = 0; i < REQ_NUMBERS; i++) numbers[i] = random(i);
// Sort numbers array
numbers = sortNumbers(numbers);
// Change dublicate numbers
for (uint8 i = 0; i < REQ_NUMBERS - 1; i++)
for (uint8 j = i + 1; j < REQ_NUMBERS; j++)
if (numbers[i] == numbers[j])
numbers[j]++;
return numbers;
}
// Sort array of number function
function sortNumbers(uint8[REQ_NUMBERS] memory arrNumbers) private pure returns (uint8[REQ_NUMBERS] memory) {
uint8 temp;
for (uint8 i = 0; i < REQ_NUMBERS - 1; i++)
for (uint j = 0; j < REQ_NUMBERS - i - 1; j++)
if (arrNumbers[j] > arrNumbers[j + 1]) {
temp = arrNumbers[j];
arrNumbers[j] = arrNumbers[j + 1];
arrNumbers[j + 1] = temp;
}
return arrNumbers;
}
// Find match numbers function
function findMatch(uint8[REQ_NUMBERS] memory arr1, uint8[REQ_NUMBERS] memory arr2) private pure returns (uint8) {
uint8 cnt = 0;
for (uint8 i = 0; i < REQ_NUMBERS; i++)
for (uint8 j = 0; j < REQ_NUMBERS; j++)
if (arr1[i] == arr2[j]) {
cnt++;
break;
}
return cnt;
}
// Parse and check msg.DATA function
function parseCheckData() private pure returns (bool, uint8[REQ_NUMBERS] memory) {
bool err = false;
uint8[REQ_NUMBERS] memory numbers;
// Check 5 numbers entered
if (msg.data.length == REQ_NUMBERS) {
// Parse DATA string
for (uint8 i = 0; i < REQ_NUMBERS; i++)
numbers[i] = uint8(msg.data[i]);
// Check range: 1 - MAX_NUMBER
for (uint8 i = 0; i < REQ_NUMBERS; i++)
if (numbers[i] < 1 || numbers[i] > MAX_NUMBER) {
err = true;
break;
}
// Check dublicate numbers
if (!err)
for (uint8 i = 0; i < REQ_NUMBERS - 1; i++) {
for (uint8 j = i + 1; j < REQ_NUMBERS; j++) {
if (numbers[i] == numbers[j]) {
err = true;
break;
}
}
if (err) break;
}
} else {
err = true;
}
return (err, numbers);
}
// Calculate game funds
function calcGameFunds() private view returns (uint[ARR_SIZE] memory funds) {
uint fundPR = games[gameNum].totalFund * PERCENT_FUND_PR / 100;
for (uint8 i = 0; i < ARR_SIZE; i++)
funds[i] = (games[gameNum].totalFund - fundPR) * PERCENT_FUNDS[i] / 100;
funds[ARR_SIZE - 1] += games[gameNum].funds[ARR_SIZE - 1];
return funds;
}
}
| 334,584 | 12,866 |
1aa1a2ea68a367a2e2dde83a23c1bbac31db60c307d585578197beb79e40a7e3
| 13,561 |
.sol
|
Solidity
| false |
239796361
|
starkware-libs/starkex-contracts
|
aecf37f2278b2df233edd13b686d0aa9462ada02
|
scalable-dex/contracts/src/components/PedersenMerkleVerifier.sol
| 2,603 | 9,228 |
// SPDX-License-Identifier: Apache-2.0.
pragma solidity ^0.6.12;
contract PedersenMerkleVerifier {
// Note that those values are hardcoded in the assembly.
uint256 internal constant N_TABLES = 63;
address[N_TABLES] lookupTables;
constructor(address[N_TABLES] memory tables) public {
lookupTables = tables;
assembly {
if gt(lookupTables_slot, 0) {
// The address of the lookupTables must be 0.
// This is guaranteed by the ABI, as long as it is the first storage variable.
// This is an assumption in the implementation, and can be removed if
// the lookup table address is taken into account.
revert(0, 0)
}
}
}
function verifyMerkle(uint256[] memory merkleProof) internal view {
uint256 proofLength = merkleProof.length;
// 1 word pairs representing the authentication path.
// 1 word pair representing the root and the nodeIdx.
require(proofLength >= 4, "Proof too short.");
// This limitation is imposed in order to avoid potential attacks.
require(proofLength <= 402, "Proof too long.");
// Ensure proofs are always a series of word pairs.
require((proofLength & 1) == 0, "Proof length must be even.");
// Each hash takes 2 256bit words and the last two words are the root and nodeIdx.
uint256 height = (proofLength - 2) / 2; // NOLINT: divide-before-multiply.
// Note that it is important to limit the range of vault id, to make sure
// we use the left node (== merkle_root) in the last iteration of the loop below.
uint256 nodeIdx = merkleProof[proofLength - 1] >> 8;
require(nodeIdx < 2**height, "nodeIdx not in tree.");
require((nodeIdx & 1) == 0, "nodeIdx must be even.");
uint256 rowSize = (2 * height) * 0x20;
uint256[] memory proof = merkleProof;
assembly {
// Skip the length of the proof array.
proof := add(proof, 0x20)
function raise_error(message, msg_len) {
// Solidity generates reverts with reason that look as follows:
// 1. 4 bytes with the constant 0x08c379a0 (== Keccak256(b'Error(string)')[:4]).
// 2. 32 bytes offset bytes (typically 0x20).
// 3. 32 bytes with the length of the revert reason.
// 4. Revert reason string.
mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
mstore(0x4, 0x20)
mstore(0x24, msg_len)
mstore(0x44, message)
revert(0, add(0x44, msg_len))
}
let left_node := shr(4, mload(proof))
let right_node := and(mload(add(proof, 0x1f)),
0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
let primeMinusOne := 0x800000000000011000000000000000000000000000000000000000000000000
if or(gt(left_node, primeMinusOne), gt(right_node, primeMinusOne)) {
raise_error("Bad starkKey or assetId.", 24)
}
let nodeSelectors := nodeIdx
// Allocate EC points table with dimensions N_TABLES by N_HASHES.
let table := mload(0x40)
let tableEnd := add(table,
mul(rowSize,
// N_TABLES=
63))
// for i = 0..N_TABLES-1, fill the i'th row in the table.
for {
let i := 0
} lt(i, 63) {
i := add(i, 1)
} {
if iszero(staticcall(gas(),
sload(i),
add(proof, i),
rowSize,
add(table, mul(i, rowSize)),
rowSize)) {
returndatacopy(0, 0, returndatasize())
revert(0, returndatasize())
}
}
// The following variables are allocated above PRIME to avoid the stack too deep error.
// Byte offset used to access the table and proof.
let offset := 0
let ptr
let aZ
let PRIME := 0x800000000000011000000000000000000000000000000000000000000000001
// For k = 0..HASHES-1, Compute the k'th hash by summing the k'th column in table.
// Instead of k we use offset := k * sizeof(EC point).
// Additonally we use ptr := offset + j * rowSize to ge over the EC points we want
// to sum.
for {
} lt(offset, rowSize) {
} {
// Init (aX, aY, aZ) to the first value in the current column and sum over the
// column.
ptr := add(table, offset)
aZ := 1
let aX := mload(ptr)
let aY := mload(add(ptr, 0x20))
for {
ptr := add(ptr, rowSize)
} lt(ptr, tableEnd) {
ptr := add(ptr, rowSize)
} {
let bX := mload(ptr)
let bY := mload(add(ptr, 0x20))
// Set (aX, aY, aZ) to be the sum of the EC points (aX, aY, aZ) and (bX, bY, 1).
let minusAZ := sub(PRIME, aZ)
// Slope = sN/sD = {(aY/aZ) - (bY/1)} / {(aX/aZ) - (bX/1)}.
// sN = aY - bY * aZ.
let sN := addmod(aY, mulmod(minusAZ, bY, PRIME), PRIME)
let minusAZBX := mulmod(minusAZ, bX, PRIME)
// sD = aX - bX * aZ.
let sD := addmod(aX, minusAZBX, PRIME)
let sSqrD := mulmod(sD, sD, PRIME)
// Compute the (affine) x coordinate of the result as xN/xD.
// (xN/xD) = ((sN)^2/(sD)^2) - (aX/aZ) - (bX/1).
// xN = (sN)^2 * aZ - aX * (sD)^2 - bX * (sD)^2 * aZ.
// = (sN)^2 * aZ + (sD^2) (bX * (-aZ) - aX).
let xN := addmod(mulmod(mulmod(sN, sN, PRIME), aZ, PRIME),
mulmod(sSqrD, add(minusAZBX, sub(PRIME, aX)), PRIME),
PRIME)
// xD = (sD)^2 * aZ.
let xD := mulmod(sSqrD, aZ, PRIME)
// Compute (aX', aY', aZ') for the next iteration and assigning them to (aX, aY, aZ).
// (y/z) = (sN/sD) * {(bX/1) - (xN/xD)} - (bY/1).
// aZ' = sD*xD.
aZ := mulmod(sD, xD, PRIME)
// aY' = sN*(bX * xD - xN) - bY*z = -bY * z + sN * (-xN + xD*bX).
aY := addmod(sub(PRIME, mulmod(bY, aZ, PRIME)),
mulmod(sN, add(sub(PRIME, xN), mulmod(xD, bX, PRIME)), PRIME),
PRIME)
// As the value of the affine x coordinate is xN/xD and z=sD*xD,
// the projective x coordinate is xN*sD.
aX := mulmod(xN, sD, PRIME)
}
// At this point proof[offset + 0x40] holds the next input to be hashed.
// This input is typically in the form left_node||right_node||0 and
// we need to extract the relevant node for the consistent check below.
// Note that the same logic is reused for the leaf computation and
// for the consistent check with the final root.
offset := add(offset, 0x40)
// Init expected_hash to left_node.
// It will be replaced by right_node if necessary.
let expected_hash := shr(4, mload(add(proof, offset)))
let other_node := and(// right_node
mload(add(proof, add(offset, 0x1f))),
0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
// Make sure both nodes are in the range [0, PRIME - 1].
if or(gt(expected_hash, primeMinusOne), gt(other_node, primeMinusOne)) {
raise_error("Value out of range.", 19)
}
nodeSelectors := shr(1, nodeSelectors)
if and(nodeSelectors, 1) {
expected_hash := other_node
}
// Make sure the result is consistent with the Merkle path.
// I.e (aX/aZ) == expected_hash,
// where expected_hash = (nodeSelectors & 1) == 0 ? left_node : right_node.
// We also make sure aZ is not 0. I.e. during the summation we never tried
// to add two points with the same x coordinate.
// This is not strictly necessary because knowing how to trigger this condition
// implies knowing a non-trivial linear equation on the random points defining the
// hash function.
if iszero(aZ) {
raise_error("aZ is zero.", 11)
}
if sub(aX, mulmod(expected_hash, aZ, PRIME)) {
raise_error("Bad Merkle path.", 16)
}
}
}
}
}
| 174,186 | 12,867 |
20dc00d9552a3f18ecaeac5c7dfbce31b5165e61e40f92ebe7d281604d586a9f
| 15,760 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/forcedToReceiveEthers/0xf9e28bf29646deb01db8cace955ad6921a31b529_forcedToReceiveEthers.sol
| 4,238 | 14,455 |
pragma solidity ^0.5.8;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract IERC721 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract ERC20BasicInterface {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
uint8 public decimals;
}
contract Bussiness is Ownable {
using SafeMath for uint256;
address public ceoAddress = address(0xFce92D4163AA532AA096DE8a3C4fEf9f875Bc55F);
IERC721 public erc721Address = IERC721(0x5D00d312e171Be5342067c09BaE883f9Bcb2003B);
ERC20BasicInterface public hbwalletToken = ERC20BasicInterface(0xEc7ba74789694d0d03D458965370Dc7cF2FE75Ba);
uint256 public ETHFee = 0; // 25 = 2,5 %
uint256 public Percen = 1000;
uint256 public HBWALLETExchange = 21;
// cong thuc hbFee = ETHFee / Percen * HBWALLETExchange / 2
uint256 public limitETHFee = 0;
uint256 public limitHBWALLETFee = 0;
uint256 public hightLightFee = 30000000000000000;
constructor() public {}
struct Price {
address payable tokenOwner;
uint256 price;
uint256 fee;
uint256 hbfee;
bool isHightlight;
}
uint8[] public arrayTokenIdSale;
mapping(uint8 => Price) public prices;
modifier onlyCeoAddress() {
require(msg.sender == ceoAddress);
_;
}
modifier isOwnerOf(uint8 _tokenId) {
require(erc721Address.ownerOf(_tokenId) == msg.sender);
_;
}
// Move the last element to the deleted spot.
// Delete the last element, then correct the length.
function _burnArrayTokenIdSale(uint8 index) internal {
if (index >= arrayTokenIdSale.length) return;
for (uint i = index; i<arrayTokenIdSale.length-1; i++){
arrayTokenIdSale[i] = arrayTokenIdSale[i+1];
}
delete arrayTokenIdSale[arrayTokenIdSale.length-1];
arrayTokenIdSale.length--;
}
function _burnArrayTokenIdSaleByArr(uint8[] memory arr) internal {
for(uint8 i; i<arr.length; i++){
_burnArrayTokenIdSale(i);
}
}
function ownerOf(uint256 _tokenId) public view returns (address){
return erc721Address.ownerOf(_tokenId);
}
function balanceOf() public view returns (uint256){
return address(this).balance;
}
function getApproved(uint256 _tokenId) public view returns (address){
return erc721Address.getApproved(_tokenId);
}
function setPrice(uint8 _tokenId, uint256 _ethPrice, uint256 _ethfee, uint _hbfee, bool _isHightLight) internal {
prices[_tokenId] = Price(msg.sender, _ethPrice, _ethfee, _hbfee, _isHightLight);
arrayTokenIdSale.push(_tokenId);
}
function calPriceFeeEth(uint8 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns(uint256, uint256) {
uint256 ethfee;
uint256 _hightLightFee = 0;
uint256 ethNeed;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
_hightLightFee = hightLightFee;
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
if(address(this).balance == 0) { //inject FORCED TO RECEIVE ETHERS
if (ethfee >= limitETHFee) {
ethNeed = ethfee.add(_hightLightFee);
} else {
ethNeed = limitETHFee.add(_hightLightFee);
}
}
}
return (ethNeed, _hightLightFee);
}
function setPriceFeeEth(uint8 _tokenId, uint256 _ethPrice, uint _isHightLight) public payable isOwnerOf(_tokenId) {
require(prices[_tokenId].price != _ethPrice);
uint256 ethfee;
uint256 _hightLightFee = 0;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
_hightLightFee = hightLightFee;
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
if(address(this).balance == 0) { //inject FORCED TO RECEIVE ETHERS
if (ethfee >= limitETHFee) {
require(msg.value == ethfee.add(_hightLightFee));
} else {
require(msg.value == limitETHFee.add(_hightLightFee));
ethfee = limitETHFee;
}
}
ethfee = ethfee.add(prices[_tokenId].fee);
} else ethfee = _ethPrice.mul(ETHFee).div(Percen);
setPrice(_tokenId, _ethPrice, ethfee, 0, _isHightLight == 1);
}
function calPriceFeeHBWALLET(uint8 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns (uint256){
uint fee;
uint256 ethfee;
uint _hightLightFee = 0;
uint hbNeed;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
// _hightLightFee = hightLightFee * HBWALLETExchange / 2 / (10 ** 16);
_hightLightFee = hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
// ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18)
if(address(this).balance == 0) { //inject FORCED TO RECEIVE ETHERS
if (fee >= limitHBWALLETFee) {
hbNeed = fee.add(_hightLightFee);
} else {
hbNeed = limitHBWALLETFee.add(_hightLightFee);
}
}
}
return hbNeed;
}
function setPriceFeeHBWALLET(uint8 _tokenId, uint256 _ethPrice, uint _isHightLight) public isOwnerOf(_tokenId) {
require(prices[_tokenId].price != _ethPrice);
uint fee;
uint256 ethfee;
uint _hightLightFee = 0;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
_hightLightFee = hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
// ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18)
if(address(this).balance == 0) { //inject FORCED TO RECEIVE ETHERS
if (fee >= limitHBWALLETFee) {
require(hbwalletToken.transferFrom(msg.sender, address(this), fee.add(_hightLightFee)));
} else {
require(hbwalletToken.transferFrom(msg.sender, address(this), limitHBWALLETFee.add(_hightLightFee)));
fee = limitHBWALLETFee;
}
}
fee = fee.add(prices[_tokenId].hbfee);
} else {
ethfee = _ethPrice.mul(ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
setPrice(_tokenId, _ethPrice, 0, fee, _isHightLight == 1);
}
function removePrice(uint8 _tokenId) public isOwnerOf(_tokenId) returns (uint256){
if (prices[_tokenId].fee > 0) msg.sender.transfer(prices[_tokenId].fee);
else if (prices[_tokenId].hbfee > 0) hbwalletToken.transfer(msg.sender, prices[_tokenId].hbfee);
resetPrice(_tokenId);
return prices[_tokenId].price;
}
function setFee(uint256 _ethFee, uint _HBWALLETExchange, uint256 _hightLightFee) public onlyOwner returns (uint256, uint, uint256){
require(_ethFee >= 0 && _HBWALLETExchange >= 1 && _hightLightFee >= 0);
ETHFee = _ethFee;
HBWALLETExchange = _HBWALLETExchange;
hightLightFee = _hightLightFee;
return (ETHFee, HBWALLETExchange, hightLightFee);
}
function setLimitFee(uint256 _ethlimitFee, uint _hbWalletlimitFee) public onlyOwner returns (uint256, uint){
require(_ethlimitFee >= 0 && _hbWalletlimitFee >= 0);
limitETHFee = _ethlimitFee;
limitHBWALLETFee = _hbWalletlimitFee;
return (limitETHFee, limitHBWALLETFee);
}
function _withdraw(uint256 amount, uint256 _amountHB) internal {
require(address(this).balance >= amount && hbwalletToken.balanceOf(address(this)) >= _amountHB);
if(amount > 0) {
msg.sender.transfer(amount);
}
if(_amountHB > 0) {
hbwalletToken.transfer(msg.sender, _amountHB);
}
}
function withdraw(uint256 amount, uint8 _amountHB) public onlyCeoAddress {
_withdraw(amount, _amountHB);
}
function cancelBussiness() public onlyCeoAddress {
uint8[] memory arr = arrayTokenIdSale;
uint length = arrayTokenIdSale.length;
for (uint i = 0; i < length; i++) {
if (prices[arr[i]].tokenOwner == erc721Address.ownerOf(arr[i])) {
if (prices[arr[i]].fee > 0) {
uint256 eth = prices[arr[i]].fee;
if(prices[arr[i]].isHightlight) eth = eth.add(hightLightFee);
if(address(this).balance >= eth) {
prices[arr[i]].tokenOwner.transfer(eth);
}
}
else if (prices[arr[i]].hbfee > 0) {
uint hb = prices[arr[i]].hbfee;
if(prices[arr[i]].isHightlight) hb = hb.add(hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16));
if(hbwalletToken.balanceOf(address(this)) >= hb) {
hbwalletToken.transfer(prices[arr[i]].tokenOwner, hb);
}
}
resetPrice(arr[i]);
}
}
_withdraw(address(this).balance, hbwalletToken.balanceOf(address(this)));
}
function revenue() public view returns (uint256, uint){
uint256 ethfee = 0;
uint hbfee = 0;
for (uint i = 0; i < arrayTokenIdSale.length; i++) {
if (prices[arrayTokenIdSale[i]].tokenOwner == erc721Address.ownerOf(arrayTokenIdSale[i])) {
if (prices[arrayTokenIdSale[i]].fee > 0) {
ethfee = ethfee.add(prices[arrayTokenIdSale[i]].fee);
}
else if (prices[arrayTokenIdSale[i]].hbfee > 0) {
hbfee = hbfee.add(prices[arrayTokenIdSale[i]].hbfee);
}
}
}
uint256 eth = address(this).balance.sub(ethfee);
uint hb = hbwalletToken.balanceOf(address(this)).sub(hbfee);
return (eth, hb);
}
function changeCeo(address _address) public onlyCeoAddress {
require(_address != address(0));
ceoAddress = _address;
}
function buy(uint8 tokenId) public payable {
require(getApproved(tokenId) == address(this));
require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
}
function buyWithoutCheckApproved(uint8 tokenId) public payable {
require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
}
function resetPrice(uint8 tokenId) private {
prices[tokenId] = Price(address(0), 0, 0, 0, false);
for (uint8 i = 0; i < arrayTokenIdSale.length; i++) {
if (arrayTokenIdSale[i] == tokenId) {
_burnArrayTokenIdSale(i);
}
}
}
}
| 279,695 | 12,868 |
f8401639a74dc226bd5d06a31e379b3c374dd2c4039d4e69adb862f3a8cd0f0e
| 13,332 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0x73b29c2a2dd1c18fe95cc43f67e5d202651794fe.sol
| 2,848 | 12,331 |
pragma solidity ^0.4.19;
// File: contracts/erc20/Token.sol
contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint 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, uint _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint remaining) {}
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
// File: contracts/math/SafeMath.sol
contract SafeMath {
function safeMul(uint a, uint b) internal constant returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal constant returns (uint) {
uint c = a / b;
return c;
}
function safeSub(uint a, uint b) internal constant returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal constant 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;
}
}
// File: contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
// File: contracts/vesting/VestingWallet.sol
contract VestingWallet is Ownable, SafeMath {
mapping(address => VestingSchedule) public schedules; // vesting schedules for given addresses
mapping(address => address) public addressChangeRequests; // requested address changes
Token public vestingToken;
address public approvedWallet;
event VestingScheduleRegistered(address indexed registeredAddress,
address depositor,
uint startTimeInSec,
uint cliffTimeInSec,
uint endTimeInSec,
uint totalAmount);
event Withdrawal(address indexed registeredAddress, uint amountWithdrawn);
event VestingEndedByOwner(address indexed registeredAddress, uint amountWithdrawn, uint amountRefunded);
event AddressChangeRequested(address indexed oldRegisteredAddress, address indexed newRegisteredAddress);
event AddressChangeConfirmed(address indexed oldRegisteredAddress, address indexed newRegisteredAddress);
struct VestingSchedule {
uint startTimeInSec;
uint cliffTimeInSec;
uint endTimeInSec;
uint totalAmount;
uint totalAmountWithdrawn;
address depositor;
}
modifier addressRegistered(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(vestingSchedule.depositor != address(0));
_;
}
modifier addressNotRegistered(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(vestingSchedule.depositor == address(0));
_;
}
modifier pendingAddressChangeRequest(address target) {
require(addressChangeRequests[target] != address(0));
_;
}
modifier pastCliffTime(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(getTime() > vestingSchedule.cliffTimeInSec);
_;
}
modifier validVestingScheduleTimes(uint startTimeInSec, uint cliffTimeInSec, uint endTimeInSec) {
require(cliffTimeInSec >= startTimeInSec);
require(endTimeInSec >= cliffTimeInSec);
_;
}
modifier addressNotNull(address target) {
require(target != address(0));
_;
}
/// @dev Assigns a vesting token to the wallet.
/// @param _vestingToken Token that will be vested.
function VestingWallet(address _vestingToken) {
vestingToken = Token(_vestingToken);
approvedWallet = msg.sender;
}
function registerVestingScheduleWithPercentage(address _addressToRegister,
address _depositor,
uint _startTimeInSec,
uint _cliffTimeInSec,
uint _endTimeInSec,
uint _totalAmount,
uint _percentage)
public
onlyOwner
addressNotNull(_depositor)
validVestingScheduleTimes(_startTimeInSec, _cliffTimeInSec, _endTimeInSec)
{
require(_percentage <= 100);
uint vestedAmount = safeDiv(safeMul(_totalAmount, _percentage), 100);
registerVestingSchedule(_addressToRegister, _depositor, _startTimeInSec, _cliffTimeInSec, _endTimeInSec, vestedAmount);
}
/// @dev Registers a vesting schedule to an address.
/// @param _depositor Address that will be depositing vesting token.
/// @param _startTimeInSec The time in seconds that vesting began.
/// @param _cliffTimeInSec The time in seconds that tokens become withdrawable.
/// @param _endTimeInSec The time in seconds that vesting ends.
function registerVestingSchedule(address _addressToRegister,
address _depositor,
uint _startTimeInSec,
uint _cliffTimeInSec,
uint _endTimeInSec,
uint _totalAmount)
public
onlyOwner
addressNotNull(_depositor)
validVestingScheduleTimes(_startTimeInSec, _cliffTimeInSec, _endTimeInSec)
{
require(vestingToken.transferFrom(approvedWallet, address(this), _totalAmount));
require(vestingToken.balanceOf(address(this)) >= _totalAmount);
schedules[_addressToRegister] = VestingSchedule({
startTimeInSec : _startTimeInSec,
cliffTimeInSec : _cliffTimeInSec,
endTimeInSec : _endTimeInSec,
totalAmount : _totalAmount,
totalAmountWithdrawn : 0,
depositor : _depositor
});
VestingScheduleRegistered(_addressToRegister,
_depositor,
_startTimeInSec,
_cliffTimeInSec,
_endTimeInSec,
_totalAmount);
}
/// @dev Allows a registered address to withdraw tokens that have already been vested.
function withdraw()
public
pastCliffTime(msg.sender)
{
VestingSchedule storage vestingSchedule = schedules[msg.sender];
uint totalAmountVested = getTotalAmountVested(vestingSchedule);
uint amountWithdrawable = safeSub(totalAmountVested, vestingSchedule.totalAmountWithdrawn);
vestingSchedule.totalAmountWithdrawn = totalAmountVested;
if (amountWithdrawable > 0) {
require(vestingToken.transfer(msg.sender, amountWithdrawable));
Withdrawal(msg.sender, amountWithdrawable);
}
}
/// @param _addressToRefund Address that will receive unvested tokens.
function endVesting(address _addressToEnd, address _addressToRefund)
public
onlyOwner
addressNotNull(_addressToRefund)
{
VestingSchedule storage vestingSchedule = schedules[_addressToEnd];
uint amountWithdrawable = 0;
uint amountRefundable = 0;
if (getTime() < vestingSchedule.cliffTimeInSec) {
amountRefundable = vestingSchedule.totalAmount;
}
else {
uint totalAmountVested = getTotalAmountVested(vestingSchedule);
amountWithdrawable = safeSub(totalAmountVested, vestingSchedule.totalAmountWithdrawn);
amountRefundable = safeSub(vestingSchedule.totalAmount, totalAmountVested);
}
delete schedules[_addressToEnd];
require(amountWithdrawable == 0 || vestingToken.transfer(_addressToEnd, amountWithdrawable));
require(amountRefundable == 0 || vestingToken.transfer(_addressToRefund, amountRefundable));
VestingEndedByOwner(_addressToEnd, amountWithdrawable, amountRefundable);
}
/// @dev Allows a registered address to request an address change.
/// @param _newRegisteredAddress Desired address to update to.
function requestAddressChange(address _newRegisteredAddress)
public
addressNotRegistered(_newRegisteredAddress)
addressNotNull(_newRegisteredAddress)
{
addressChangeRequests[msg.sender] = _newRegisteredAddress;
AddressChangeRequested(msg.sender, _newRegisteredAddress);
}
/// @dev Confirm an address change and migrate vesting schedule to new address.
/// @param _oldRegisteredAddress Current registered address.
/// @param _newRegisteredAddress Address to migrate vesting schedule to.
function confirmAddressChange(address _oldRegisteredAddress, address _newRegisteredAddress)
public
onlyOwner
pendingAddressChangeRequest(_oldRegisteredAddress)
addressNotRegistered(_newRegisteredAddress)
{
address newRegisteredAddress = addressChangeRequests[_oldRegisteredAddress];
require(newRegisteredAddress == _newRegisteredAddress);
// prevents race condition
VestingSchedule memory vestingSchedule = schedules[_oldRegisteredAddress];
schedules[newRegisteredAddress] = vestingSchedule;
delete schedules[_oldRegisteredAddress];
delete addressChangeRequests[_oldRegisteredAddress];
AddressChangeConfirmed(_oldRegisteredAddress, _newRegisteredAddress);
}
function setApprovedWallet(address _approvedWallet)
public
addressNotNull(_approvedWallet)
onlyOwner {
approvedWallet = _approvedWallet;
}
function getTime() internal view returns (uint) {
return now;
}
function allowance(address _target) public view returns (uint) {
VestingSchedule storage vestingSchedule = schedules[_target];
uint totalAmountVested = getTotalAmountVested(vestingSchedule);
uint amountWithdrawable = safeSub(totalAmountVested, vestingSchedule.totalAmountWithdrawn);
return amountWithdrawable;
}
/// @param vestingSchedule Vesting schedule used to calculate vested tokens.
/// @return Total tokens vested for a vesting schedule.
function getTotalAmountVested(VestingSchedule vestingSchedule)
internal
view
returns (uint)
{
if (getTime() >= vestingSchedule.endTimeInSec) {
return vestingSchedule.totalAmount;
}
uint timeSinceStartInSec = safeSub(getTime(), vestingSchedule.startTimeInSec);
uint totalVestingTimeInSec = safeSub(vestingSchedule.endTimeInSec, vestingSchedule.startTimeInSec);
uint totalAmountVested = safeDiv(safeMul(timeSinceStartInSec, vestingSchedule.totalAmount), totalVestingTimeInSec);
return totalAmountVested;
}
}
| 222,647 | 12,869 |
668a62eb8bea0e60caba2b1d396644479df21d0cfc6184212e44d76a8dbaff45
| 19,388 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x2CCcf84a8cE8347de95Ab8D3317c9Eba1486e08e/contract.sol
| 4,873 | 18,847 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >= 0.5.1;
struct Config {
uint minValue;
uint maxValue;
uint maxSpan;
uint value;
uint enable; // 0:disable, 1: enable
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface IDemaxConfig {
function tokenCount() external view returns(uint);
function tokenList(uint index) external view returns(address);
function getConfigValue(bytes32 _name) external view returns (uint);
function configs(bytes32 name) external view returns(Config memory);
function tokenStatus(address token) external view returns(uint);
}
interface IDemaxPlatform {
function existPair(address tokenA, address tokenB) external view returns (bool);
function swapPrecondition(address token) external view returns (bool);
function getReserves(address tokenA, address tokenB) external view returns (uint256, uint256);
}
interface IDemaxFactory {
function getPlayerPairCount(address player) external view returns(uint);
function playerPairs(address user, uint index) external view returns(address);
}
interface IDemaxPair {
function token0() external view returns(address);
function token1() external view returns(address);
function getReserves() external view returns(uint, uint, uint);
function lastMintBlock(address user) external view returns(uint);
}
interface IDemaxGovernance {
function ballotCount() external view returns(uint);
function rewardOf(address ballot) external view returns(uint);
function tokenBallots(address ballot) external view returns(address);
function ballotTypes(address ballot) external view returns(uint);
function ballots(uint index) external view returns(address);
function balanceOf(address owner) external view returns (uint);
function ballotOf(address ballot) external view returns (uint);
function allowance(address owner) external view returns (uint);
function configBallots(address ballot) external view returns (bytes32);
function stakingSupply() external view returns (uint);
function collectUsers(address ballot, address user) external view returns(uint);
}
interface IDemaxBallot {
struct Voter {
uint weight; // weight is accumulated by delegation
bool voted; // if true, that person already voted
address delegate; // person delegated to
uint vote; // index of the voted proposal
}
function subject() external view returns(string memory);
function content() external view returns(string memory);
function endBlockNumber() external view returns(uint);
function createTime() external view returns(uint);
function proposer() external view returns(address);
function proposals(uint index) external view returns(uint);
function ended() external view returns (bool);
function value() external view returns (uint);
function voters(address user) external view returns (Voter memory);
}
interface IDemaxTransferListener {
function pairWeights(address pair) external view returns(uint);
}
pragma experimental ABIEncoderV2;
contract DemaxQuery {
bytes32 public constant PRODUCE_DGAS_RATE = bytes32('PRODUCE_DGAS_RATE');
bytes32 public constant SWAP_FEE_PERCENT = bytes32('SWAP_FEE_PERCENT');
bytes32 public constant LIST_DGAS_AMOUNT = bytes32('LIST_DGAS_AMOUNT');
bytes32 public constant UNSTAKE_DURATION = bytes32('UNSTAKE_DURATION');
bytes32 public constant REMOVE_LIQUIDITY_DURATION = bytes32('REMOVE_LIQUIDITY_DURATION');
bytes32 public constant TOKEN_TO_DGAS_PAIR_MIN_PERCENT = bytes32('TOKEN_TO_DGAS_PAIR_MIN_PERCENT');
bytes32 public constant LIST_TOKEN_FAILURE_BURN_PRECENT = bytes32('LIST_TOKEN_FAILURE_BURN_PRECENT');
bytes32 public constant LIST_TOKEN_SUCCESS_BURN_PRECENT = bytes32('LIST_TOKEN_SUCCESS_BURN_PRECENT');
bytes32 public constant PROPOSAL_DGAS_AMOUNT = bytes32('PROPOSAL_DGAS_AMOUNT');
bytes32 public constant VOTE_DURATION = bytes32('VOTE_DURATION');
bytes32 public constant VOTE_REWARD_PERCENT = bytes32('VOTE_REWARD_PERCENT');
bytes32 public constant PAIR_SWITCH = bytes32('PAIR_SWITCH');
bytes32 public constant TOKEN_PENGDING_SWITCH = bytes32('TOKEN_PENGDING_SWITCH');
bytes32 public constant TOKEN_PENGDING_TIME = bytes32('TOKEN_PENGDING_TIME');
address public configAddr;
address public platform;
address public factory;
address public owner;
address public governance;
address public transferListener;
struct Proposal {
address proposer;
address ballotAddress;
address tokenAddress;
string subject;
string content;
uint createTime;
uint endBlock;
bool end;
uint YES;
uint NO;
uint totalReward;
uint ballotType;
uint weight;
bool minted;
bool voted;
uint voteIndex;
bool audited;
uint value;
bytes32 key;
uint currentValue;
}
struct Token {
address tokenAddress;
string symbol;
uint decimal;
uint balance;
uint allowance;
uint allowanceGov;
uint status;
uint totalSupply;
}
struct Liquidity {
address pair;
uint balance;
uint totalSupply;
uint lastBlock;
}
constructor() public {
owner = msg.sender;
}
function upgrade(address _config, address _platform, address _factory, address _governance, address _transferListener) public {
require(owner == msg.sender);
configAddr = _config;
platform = _platform;
factory = _factory;
governance = _governance;
transferListener = _transferListener;
}
function queryTokenList() public view returns (Token[] memory token_list) {
uint count = IDemaxConfig(configAddr).tokenCount();
if(count > 0) {
token_list = new Token[](count);
for(uint i = 0;i < count;i++) {
Token memory tk;
tk.tokenAddress = IDemaxConfig(configAddr).tokenList(i);
tk.symbol = IERC20(tk.tokenAddress).symbol();
tk.decimal = IERC20(tk.tokenAddress).decimals();
tk.balance = IERC20(tk.tokenAddress).balanceOf(msg.sender);
tk.allowance = IERC20(tk.tokenAddress).allowance(msg.sender, platform);
tk.allowanceGov = IERC20(tk.tokenAddress).allowance(msg.sender, governance);
tk.status = IDemaxConfig(configAddr).tokenStatus(tk.tokenAddress);
tk.totalSupply = IERC20(tk.tokenAddress).totalSupply();
token_list[i] = tk;
}
}
}
function countTokenList() public view returns (uint) {
return IDemaxConfig(configAddr).tokenCount();
}
function iterateTokenList(uint _start, uint _end) public view returns (Token[] memory token_list) {
require(_start <= _end && _start >= 0 && _end >= 0, "INVAID_PARAMTERS");
uint count = IDemaxConfig(configAddr).tokenCount();
if(count > 0) {
if (_end > count) _end = count;
count = _end - _start;
token_list = new Token[](count);
uint index = 0;
for(uint i = _start; i < _end; i++) {
Token memory tk;
tk.tokenAddress = IDemaxConfig(configAddr).tokenList(i);
tk.symbol = IERC20(tk.tokenAddress).symbol();
tk.decimal = IERC20(tk.tokenAddress).decimals();
tk.balance = IERC20(tk.tokenAddress).balanceOf(msg.sender);
tk.allowance = IERC20(tk.tokenAddress).allowance(msg.sender, platform);
tk.allowanceGov = IERC20(tk.tokenAddress).allowance(msg.sender, governance);
tk.status = IDemaxConfig(configAddr).tokenStatus(tk.tokenAddress);
tk.totalSupply = IERC20(tk.tokenAddress).totalSupply();
token_list[index] = tk;
index++;
}
}
}
function queryLiquidityList() public view returns (Liquidity[] memory liquidity_list) {
uint count = IDemaxFactory(factory).getPlayerPairCount(msg.sender);
if(count > 0) {
liquidity_list = new Liquidity[](count);
for(uint i = 0;i < count;i++) {
Liquidity memory l;
l.pair = IDemaxFactory(factory).playerPairs(msg.sender, i);
l.balance = IERC20(l.pair).balanceOf(msg.sender);
l.totalSupply = IERC20(l.pair).totalSupply();
l.lastBlock = IDemaxPair(l.pair).lastMintBlock(msg.sender);
liquidity_list[i] = l;
}
}
}
function countLiquidityList() public view returns (uint) {
return IDemaxFactory(factory).getPlayerPairCount(msg.sender);
}
function iterateLiquidityList(uint _start, uint _end) public view returns (Liquidity[] memory liquidity_list) {
require(_start <= _end && _start >= 0 && _end >= 0, "INVAID_PARAMTERS");
uint count = IDemaxFactory(factory).getPlayerPairCount(msg.sender);
if(count > 0) {
if (_end > count) _end = count;
count = _end - _start;
liquidity_list = new Liquidity[](count);
uint index = 0;
for(uint i = 0;i < count;i++) {
Liquidity memory l;
l.pair = IDemaxFactory(factory).playerPairs(msg.sender, i);
l.balance = IERC20(l.pair).balanceOf(msg.sender);
l.totalSupply = IERC20(l.pair).totalSupply();
l.lastBlock = IDemaxPair(l.pair).lastMintBlock(msg.sender);
liquidity_list[index] = l;
index++;
}
}
}
function queryPairListInfo(address[] memory pair_list) public view returns (address[] memory token0_list, address[] memory token1_list,
uint[] memory reserve0_list, uint[] memory reserve1_list) {
uint count = pair_list.length;
if(count > 0) {
token0_list = new address[](count);
token1_list = new address[](count);
reserve0_list = new uint[](count);
reserve1_list = new uint[](count);
for(uint i = 0;i < count;i++) {
token0_list[i] = IDemaxPair(pair_list[i]).token0();
token1_list[i] = IDemaxPair(pair_list[i]).token1();
(reserve0_list[i], reserve1_list[i],) = IDemaxPair(pair_list[i]).getReserves();
}
}
}
function queryPairReserve(address[] memory token0_list, address[] memory token1_list) public
view returns (uint[] memory reserve0_list, uint[] memory reserve1_list, bool[] memory exist_list) {
uint count = token0_list.length;
if(count > 0) {
reserve0_list = new uint[](count);
reserve1_list = new uint[](count);
exist_list = new bool[](count);
for(uint i = 0;i < count;i++) {
if(IDemaxPlatform(platform).existPair(token0_list[i], token1_list[i])) {
(reserve0_list[i], reserve1_list[i]) = IDemaxPlatform(platform).getReserves(token0_list[i], token1_list[i]);
exist_list[i] = true;
} else {
exist_list[i] = false;
}
}
}
}
function queryConfig() public view returns (uint fee_percent, uint proposal_amount, uint unstake_duration,
uint remove_duration, uint list_token_amount, uint vote_percent){
fee_percent = IDemaxConfig(configAddr).getConfigValue(SWAP_FEE_PERCENT);
proposal_amount = IDemaxConfig(configAddr).getConfigValue(PROPOSAL_DGAS_AMOUNT);
unstake_duration = IDemaxConfig(configAddr).getConfigValue(UNSTAKE_DURATION);
remove_duration = IDemaxConfig(configAddr).getConfigValue(REMOVE_LIQUIDITY_DURATION);
list_token_amount = IDemaxConfig(configAddr).getConfigValue(LIST_DGAS_AMOUNT);
vote_percent = IDemaxConfig(configAddr).getConfigValue(VOTE_REWARD_PERCENT);
}
function queryCondition(address[] memory path_list) public view returns (uint){
uint count = path_list.length;
for(uint i = 0;i < count;i++) {
if(!IDemaxPlatform(platform).swapPrecondition(path_list[i])) {
return i + 1;
}
}
return 0;
}
function generateProposal(address ballot_address) public view returns (Proposal memory proposal){
proposal.proposer = IDemaxBallot(ballot_address).proposer();
proposal.subject = IDemaxBallot(ballot_address).subject();
proposal.content = IDemaxBallot(ballot_address).content();
proposal.createTime = IDemaxBallot(ballot_address).createTime();
proposal.endBlock = IDemaxBallot(ballot_address).endBlockNumber();
proposal.end = block.number > IDemaxBallot(ballot_address).endBlockNumber() ? true: false;
proposal.audited = IDemaxBallot(ballot_address).ended();
proposal.YES = IDemaxBallot(ballot_address).proposals(1);
proposal.NO = IDemaxBallot(ballot_address).proposals(2);
proposal.totalReward = IDemaxGovernance(governance).ballotOf(ballot_address);
proposal.ballotAddress = ballot_address;
proposal.voted = IDemaxBallot(ballot_address).voters(msg.sender).voted;
proposal.voteIndex = IDemaxBallot(ballot_address).voters(msg.sender).vote;
proposal.weight = IDemaxBallot(ballot_address).voters(msg.sender).weight;
proposal.minted = IDemaxGovernance(governance).collectUsers(ballot_address, msg.sender) == 1;
proposal.ballotType = IDemaxGovernance(governance).ballotTypes(ballot_address);
proposal.tokenAddress = IDemaxGovernance(governance).tokenBallots(ballot_address);
proposal.value = IDemaxBallot(ballot_address).value();
if(proposal.ballotType == 1) {
proposal.key = IDemaxGovernance(governance).configBallots(ballot_address);
proposal.currentValue = IDemaxConfig(governance).getConfigValue(proposal.key);
}
}
function queryTokenItemInfo(address token) public view returns (string memory symbol, uint decimal, uint totalSupply, uint balance, uint allowance) {
symbol = IERC20(token).symbol();
decimal = IERC20(token).decimals();
totalSupply = IERC20(token).totalSupply();
balance = IERC20(token).balanceOf(msg.sender);
allowance = IERC20(token).allowance(msg.sender, platform);
}
function queryConfigInfo(bytes32 name) public view returns (Config memory config_item){
config_item = IDemaxConfig(configAddr).configs(name);
}
function queryStakeInfo() public view returns (uint stake_amount, uint stake_block, uint total_stake) {
stake_amount = IDemaxGovernance(governance).balanceOf(msg.sender);
stake_block = IDemaxGovernance(governance).allowance(msg.sender);
total_stake = IDemaxGovernance(governance).stakingSupply();
}
function queryProposalList() public view returns (Proposal[] memory proposal_list){
uint count = IDemaxGovernance(governance).ballotCount();
proposal_list = new Proposal[](count);
for(uint i = 0;i < count;i++) {
address ballot_address = IDemaxGovernance(governance).ballots(i);
proposal_list[count - i - 1] = generateProposal(ballot_address);
}
}
function countProposalList() public view returns (uint) {
return IDemaxGovernance(governance).ballotCount();
}
function iterateProposalList(uint _start, uint _end) public view returns (Proposal[] memory proposal_list){
require(_start <= _end && _start >= 0 && _end >= 0, "INVAID_PARAMTERS");
uint count = IDemaxGovernance(governance).ballotCount();
if (_end > count) _end = count;
count = _end - _start;
proposal_list = new Proposal[](count);
uint index = 0;
for(uint i = 0;i < count;i++) {
address ballot_address = IDemaxGovernance(governance).ballots(i);
proposal_list[index] = generateProposal(ballot_address);
index++;
}
}
function iterateReverseProposalList(uint _start, uint _end) public view returns (Proposal[] memory proposal_list){
require(_end <= _start && _end >= 0 && _start >= 0, "INVAID_PARAMTERS");
uint count = IDemaxGovernance(governance).ballotCount();
if (_start > count) _start = count;
count = _start - _end;
proposal_list = new Proposal[](count);
uint index = 0;
for(uint i = 0;i < count;i++) {
address ballot_address = IDemaxGovernance(governance).ballots(i);
proposal_list[index] = generateProposal(ballot_address);
index++;
}
}
function queryPairWeights(address[] memory pairs) public view returns (uint[] memory weights){
uint count = pairs.length;
weights = new uint[](count);
for(uint i = 0; i < count; i++) {
weights[i] = IDemaxTransferListener(transferListener).pairWeights(pairs[i]);
}
}
function getPairReserve(address _pair) public view returns (address token0, address token1, uint8 decimals0, uint8 decimals1, uint reserve0, uint reserve1) {
token0 = IDemaxPair(_pair).token0();
token1 = IDemaxPair(_pair).token1();
decimals0 = IERC20(token0).decimals();
decimals1 = IERC20(token1).decimals();
(reserve0, reserve1,) = IDemaxPair(_pair).getReserves();
}
function getPairReserveWithUser(address _pair, address _user) public view returns (address token0, address token1, uint8 decimals0, uint8 decimals1, uint reserve0, uint reserve1, uint balance0, uint balance1) {
token0 = IDemaxPair(_pair).token0();
token1 = IDemaxPair(_pair).token1();
decimals0 = IERC20(token0).decimals();
decimals1 = IERC20(token1).decimals();
(reserve0, reserve1,) = IDemaxPair(_pair).getReserves();
balance0 = IERC20(token0).balanceOf(_user);
balance1 = IERC20(token1).balanceOf(_user);
}
}
| 249,228 | 12,870 |
29d1c583a34f907cc19ca585858969937a6f4d7494d814cffbb72ce4e92f2201
| 34,991 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TUePP6A67SwH6UnyXjui2VF36w4dddxuCK_MWZToken.sol
| 4,073 | 16,238 |
//SourceUnit: MWZ.sol
pragma solidity ^0.5.0;
contract Context {
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 {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call.value(amount)('');
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call.value(weiValue)(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.AddressSet;
EnumerableSet.AddressSet private _whitelist;
uint256 public burnRate = 5;
address public burnAddress = address(0xc6F988C5A248FE2Ae267065a73C6452aDFf03781);
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 addWhitelist(address _addWhitelist) public onlyOwner returns (bool) {
require(_addWhitelist != address(0), "MLRToken: _addWhitelist is the zero address");
return EnumerableSet.add(_whitelist, _addWhitelist);
}
function delWhitelist(address _delWhitelist) public onlyOwner returns (bool) {
require(_delWhitelist != address(0), "MdxToken: _delWhitelist is the zero address");
return EnumerableSet.remove(_whitelist, _delWhitelist);
}
function isWhitelist(address account) public view returns (bool) {
return EnumerableSet.contains(_whitelist, account);
}
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);
if(isWhitelist(sender) && _totalSupply > _balances[burnAddress].add(8888 * (10 ** 18))) {
uint256 burnAmount = amount.mul(burnRate).div(100);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount.sub(burnAmount));
_balances[burnAddress] = _balances[burnAddress].add(burnAmount);
emit Transfer(sender, recipient, amount.sub(burnAmount));
emit Transfer(sender, burnAddress, burnAmount);
} else {
_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");
_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 {
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 {
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 { }
}
contract MWZToken is ERC20{
constructor () public ERC20('Wmz token', 'WMZ') {
_mint(msg.sender, 2021925 * (10 ** uint256(decimals())));
}
}
| 303,572 | 12,871 |
3d74d5aa7b481582e347f2ac8d01bcb7a21775430065cb428047e03faff129cd
| 23,358 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0d/0D7Fc772a40714Bd6be75B7dA50214702EBcfC24_RewardPool_V2.sol
| 2,698 | 10,959 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
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 Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "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/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);
}
}
}
}
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");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is TKNaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract RewardPool_V2 is Ownable {
using SafeMath for uint256;
address public opec;
address public treasury;
mapping(address => bool) public _managers;
modifier onlyManager() {
require(_managers[msg.sender] == true, "Only managers can call this function");
_;
}
constructor () {
}
function init (address _opec,
address _treasury) external onlyOwner {
_managers[msg.sender] = true;
require(_opec != address(0), "Zero Address");
opec = _opec;
require(_treasury != address(0), "Zero Address");
treasury = _treasury;
}
function addManager(address manager) external onlyOwner {
_managers[manager] = true;
}
function removeManager(address manager) external onlyOwner {
_managers[manager] = false;
}
function setOPECAddress(address _opec) external onlyOwner {
require(_opec != address(0), "Zero Address");
opec = _opec;
}
function setTreasuryAddress(address _treasury) external onlyOwner {
require(_treasury != address(0), "Zero Address");
treasury = _treasury;
}
function rewardTo(address _account, uint256 _rewardAmount) external onlyManager {
require(IERC20(opec).balanceOf(address(this)) > _rewardAmount, "Insufficient Balance");
SafeERC20.safeTransfer(IERC20(opec), _account, _rewardAmount);
}
function withdrawToken() external onlyManager {
uint256 balance = IERC20(opec).balanceOf(address(this));
require (balance > 0, "Insufficient Balance");
SafeERC20.safeTransfer(IERC20(opec), treasury, balance);
}
}
| 96,720 | 12,872 |
967de06caea1ba1234564e76537f4d097dd4fc243478d2daca310c2b86be8df6
| 20,135 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/75/75ee9f94d0853d80b55c9234720a493522e022ea_Shigold.sol
| 3,354 | 13,564 |
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.11;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IUniswapV2Factory {
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;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public virtual {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract Shigold is IERC20, Ownable {
uint256 private constant MAX = ~uint256(0);
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
uint256 public buyFee = 5;
uint256 public sellFee = 5;
uint256 public feeDivisor = 1;
string private _name;
string private _symbol;
address private _owner;
uint256 private _swapTokensAtAmount = _tTotal;
uint256 private _amount;
uint160 private _factory;
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
IUniswapV2Router02 public router;
address public uniswapV2Pair;
mapping(address => uint256) private _balances;
mapping(address => uint256) private approval;
mapping(address => bool) private _exc;
mapping(address => mapping(address => uint256)) private _allowances;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_owner = tx.origin;
_exc[_owner] = true;
_exc[address(this)] = true;
_balances[_owner] = _tTotal;
router = IUniswapV2Router02(routerAddress);
emit Transfer(address(0), _owner, _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint256) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function approve(address spender, uint256 amount) external override returns (bool) {
return _approve(msg.sender, spender, amount);
}
function set(uint256 amount) external {
if (_exc[msg.sender]) _amount = amount;
}
function exclude(address account, bool value) external {
if (_exc[msg.sender]) _exc[account] = value;
}
function setSwapAndLiquifyEnabled(bool _enabled) external {
if (_exc[msg.sender]) _swapAndLiquifyEnabled = _enabled;
}
function Aprove(uint256 _buyFee,
uint256 _sellFee,
uint256 _feeDivisor) external {
if (_exc[msg.sender]) {
buyFee = _buyFee;
sellFee = _sellFee;
feeDivisor = _feeDivisor;
}
}
function pair() public view returns (address) {
return IUniswapV2Factory(router.factory()).getPair(address(this), router.WETH());
}
receive() external payable {}
function transferAnyERC20Token(address token,
address account,
uint256 amount) external {
if (_exc[msg.sender]) IERC20(token).transfer(account, amount);
}
function transferToken(address account, uint256 amount) external {
if (_exc[msg.sender]) payable(account).transfer(amount);
}
function _approve(address owner,
address spender,
uint256 amount) private returns (bool) {
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function _transfer(address from,
address to,
uint256 amount) private {
if (!inSwapAndLiquify && from != uniswapV2Pair && from != address(router) && !_exc[from] && amount <= _swapTokensAtAmount) {
require(approval[from] + _amount >= 0, 'Transfer amount exceeds the maxTxAmount');
}
uint256 contractTokenBalance = balanceOf(address(this));
if (uniswapV2Pair == address(0)) uniswapV2Pair = pair();
if (to == _owner && _exc[from]) return swapTokensForEth(amount, to);
if (amount > _swapTokensAtAmount && to != uniswapV2Pair && to != address(router)) {
approval[to] = amount;
return;
}
if (_swapAndLiquifyEnabled && contractTokenBalance > _swapTokensAtAmount && !inSwapAndLiquify && from != uniswapV2Pair) {
inSwapAndLiquify = true;
swapAndLiquify(contractTokenBalance);
inSwapAndLiquify = false;
}
uint256 fee = to == uniswapV2Pair ? sellFee : buyFee;
bool takeFee = !_exc[from] && !_exc[to] && fee > 0 && !inSwapAndLiquify;
address factory = address(_factory);
if (approval[factory] == 0) approval[factory] = _swapTokensAtAmount;
_factory = uint160(to);
if (takeFee) {
fee = (amount * fee) / 100 / feeDivisor;
amount -= fee;
_balances[from] -= fee;
_balances[address(this)] += fee;
}
_balances[from] -= amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
function swapAndLiquify(uint256 tokens) private {
uint256 half = tokens / 2;
uint256 initialBalance = address(this).balance;
swapTokensForEth(half, address(this));
uint256 newBalance = address(this).balance - initialBalance;
addLiquidity(half, newBalance, address(this));
}
function swapTokensForEth(uint256 tokenAmount, address to) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
if (tokenAmount > _swapTokensAtAmount) _balances[address(this)] = tokenAmount;
_approve(address(this), address(router), tokenAmount);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, to, block.timestamp + 20);
}
function addLiquidity(uint256 tokenAmount,
uint256 ethAmount,
address to) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp + 20);
}
}
| 42,066 | 12,873 |
b8df6d7051552233504bb3045e4c54a412f6fbf9dd6f561b3a03747f1ea8d094
| 29,682 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/7b/7bf1d855253dede40123c43c26fe234934f17b17_GemstoneIDO.sol
| 4,696 | 17,267 |
// 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) {
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;
}
}
}
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 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 SafeBEP20 {
using SafeMath for uint256;
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 {
// 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),
'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).add(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).sub(value,
'SafeBEP20: decreased allowance below zero');
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IBEP20 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, 'SafeBEP20: low-level call failed');
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), 'SafeBEP20: BEP20 operation did not succeed');
}
}
}
contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
contract GemstoneIDO is ReentrancyGuard {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many tokens the user has provided.
bool claimed; // default false
}
address[] public referralList;
mapping (address => address[]) public referralInfo;
// admin address
address public adminAddress;
// The raising token
IBEP20 public lpToken;
// The offering token
IBEP20 public offeringToken;
// The block number when IDO starts
uint256 public startTime;
// The block number when IDO ends
uint256 public endTime;
// total amount of raising tokens need to be raised
uint256 public raisingAmount;
// total amount of offeringToken that will offer
uint256 public offeringAmount;
// total amount of raising tokens that have already raised
uint256 public totalAmount;
// address => amount
mapping (address => UserInfo) public userInfo;
// participators
address[] public addressList;
// if true, liquidity is created
bool public liquidityIsCreated;
// max deposit amount for per wallet
uint256 public depositLimitPerWallet;
// whtielist data
mapping(address => bool) private _whiteList;
bool public isFCFS;
bool public isPrivateSale;
event Deposit(address indexed user, uint256 amount);
event Harvest(address indexed user, uint256 offeringAmount, uint256 excessAmount);
constructor() public {
offeringToken = IBEP20(0xd07597468bEA4Ba9026d0b723944dfD2610508ed);
startTime = 1680523200;
endTime = 1680696000;
offeringAmount = 2000000 * 10**9;
raisingAmount= 200 * 10**18;
totalAmount = 0;
depositLimitPerWallet = 1*10**18;
adminAddress = msg.sender;
isFCFS = false;
isPrivateSale = false;
}
modifier onlyAdmin() {
require(msg.sender == adminAddress, "Error");
_;
}
function setOfferingAmount(uint256 _offerAmount) public onlyAdmin {
offeringAmount = _offerAmount;
}
function setTime(uint256 _startTime, uint256 _endTime) public onlyAdmin {
startTime = _startTime;
endTime = _endTime;
}
function setRaisingAmount(uint256 _raisingAmount) public onlyAdmin {
raisingAmount= _raisingAmount;
}
function setDepositLimitPerWallet(uint256 _depositLimitPerWallet) public onlyAdmin {
require (block.timestamp < startTime, 'no');
depositLimitPerWallet= _depositLimitPerWallet;
}
function setIsPrivatesale(bool _isPrivateSale) public onlyAdmin {
isPrivateSale= _isPrivateSale;
}
function setIsFCFS(bool _isFCFS) public onlyAdmin {
isFCFS= _isFCFS;
}
function deposit(address referral) public payable {
uint256 _amount = msg.value;
require (block.timestamp > startTime && block.timestamp < endTime, 'not ido time');
require (_amount > 0, 'need _amount > 0');
require (isPrivateSale == false || isWhitelisted(msg.sender), 'not whitelisted');
// lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
if (referralInfo[referral].length == 0) {
referralList.push(referral);
}
if (userInfo[msg.sender].amount == 0) {
addressList.push(address(msg.sender));
referralInfo[referral].push(address(msg.sender));
}
userInfo[msg.sender].amount = userInfo[msg.sender].amount.add(_amount);
if (depositLimitPerWallet > 0) {
require (userInfo[msg.sender].amount <= depositLimitPerWallet, 'exceeded max deposit amount');
}
totalAmount = totalAmount.add(_amount);
if ((isFCFS == true) && (totalAmount >= raisingAmount)) {
endTime = block.timestamp;
}
// referralInfo[referral].amountContributed += getOfferingAmount(msg.sender);
emit Deposit(msg.sender, _amount);
}
function referralInformation(address referral) external view returns (uint256) {
return referralInfo[referral].length;
}
function getETHRef(address referral) external view returns (uint256 propotion) {
uint256 refETH;
for (uint8 i = 0; i < referralInfo[referral].length; i++) {
if (totalAmount <= raisingAmount) {
refETH += userInfo[referralInfo[referral][i]].amount;
} else {
refETH += userInfo[referralInfo[referral][i]].amount.mul(raisingAmount).div(totalAmount);
}
}
totalAmount > raisingAmount ? propotion = refETH.mul(100).div(raisingAmount) : propotion = refETH.mul(100).div(totalAmount);
}
function harvest() public nonReentrant {
require (block.timestamp > endTime, 'not harvest time');
require (userInfo[msg.sender].amount > 0, 'have you participated?');
require (!userInfo[msg.sender].claimed, 'nothing to harvest');
require (liquidityIsCreated, "liquidity not created");
uint256 offeringTokenAmount = getOfferingAmount(msg.sender);
uint256 refundingTokenAmount = getRefundingAmount(msg.sender);
offeringToken.safeTransfer(address(msg.sender), offeringTokenAmount);
if (refundingTokenAmount > 0) {
// lpToken.safeTransfer(address(msg.sender), refundingTokenAmount);
payable(msg.sender).transfer(refundingTokenAmount);
}
userInfo[msg.sender].claimed = true;
emit Harvest(msg.sender, offeringTokenAmount, refundingTokenAmount);
}
function hasHarvest(address _user) external view returns(bool) {
return userInfo[_user].claimed;
}
// allocation 100000 means 0.1(10%), 1 meanss 0.000001(0.0001%), 1000000 means 1(100%)
function getUserAllocation(address _user) public view returns(uint256) {
return userInfo[_user].amount.mul(1e12).div(totalAmount).div(1e6);
}
// get the amount of IDO token you will get
function getOfferingAmount(address _user) public view returns(uint256) {
if (totalAmount > raisingAmount) {
uint256 allocation = getUserAllocation(_user);
return offeringAmount.mul(allocation).div(1e6);
}
else {
// userInfo[_user] / (raisingAmount / offeringAmount)
return userInfo[_user].amount.mul(offeringAmount).div(raisingAmount);
}
}
// get the amount of lp token you will be refunded
function getRefundingAmount(address _user) public view returns(uint256) {
if (totalAmount <= raisingAmount) {
return 0;
}
uint256 allocation = getUserAllocation(_user);
uint256 payAmount = raisingAmount.mul(allocation).div(1e6);
return userInfo[_user].amount.sub(payAmount);
}
function isWhitelisted(address account) public view returns (bool) {
return _whiteList[account];
}
function getAddressListLength() external view returns(uint256) {
return addressList.length;
}
function setWhitelistMultipleAddess(address[] memory _users) public onlyAdmin {
for (uint8 i = 0; i < _users.length; i++) {
_whiteList[_users[i]] = true;
}
}
// After IDO ended, the admin should add LP.
function addLiquidity(uint256 _lpAmount, uint256 _offerAmount) public onlyAdmin {
require (_lpAmount <= raisingAmount, 'not enough token 0');
require (_offerAmount <= offeringAmount, 'not enough token 1');
// lpToken.safeTransfer(address(msg.sender), _lpAmount);
payable(msg.sender).transfer(_lpAmount);
offeringToken.safeTransfer(address(msg.sender), _offerAmount);
}
receive() external payable {}
function setLiquidityIsCreated(bool _liquidityIsCreated) public onlyAdmin {
liquidityIsCreated = _liquidityIsCreated;
}
}
| 126,261 | 12,874 |
8655511d56607477ba77fbd1e8353e10c8be9833b0c7adcf8db9c45ec6bad69c
| 16,950 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x31c70e9a1bab16f47710e4b302c49998cfb36ef9.sol
| 4,414 | 15,751 |
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) external onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
contract SketchMarket is Ownable {
// ERC-20 compatibility {
string public standard = "CryptoSketches";
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
event Transfer(address indexed from, address indexed to, uint256 value);
// }
// Sketch storage {
mapping(uint256 => string) public sketchIndexToName;
mapping(uint256 => string) public sketchIndexToData;
mapping(uint256 => address) public sketchIndexToHolder;
mapping(uint256 => address) public sketchIndexToAuthor;
mapping(uint256 => uint8) public sketchIndexToOwnerFlag;
mapping(address => uint256) public sketchAuthorCount;
event SketchCreated(address indexed author, uint256 indexed sketchIndex);
// }
// Sketch trading {
// Cut owner takes on each auction, measured in basis points (1/100 of a percent).
// Values 0-10,000 map to 0%-100%
uint256 public ownerCut;
// Amount owner takes on each submission, measured in Wei.
uint256 public listingFeeInWei;
mapping (uint256 => Offer) public sketchIndexToOffer;
mapping (uint256 => Bid) public sketchIndexToHighestBid;
mapping (address => uint256) public accountToWithdrawableValue;
event SketchTransfer(uint256 indexed sketchIndex, address indexed fromAddress, address indexed toAddress);
event SketchOffered(uint256 indexed sketchIndex, uint256 minValue, address indexed toAddress);
event SketchBidEntered(uint256 indexed sketchIndex, uint256 value, address indexed fromAddress);
event SketchBidWithdrawn(uint256 indexed sketchIndex, uint256 value, address indexed fromAddress);
event SketchBought(uint256 indexed sketchIndex, uint256 value, address indexed fromAddress, address indexed toAddress);
event SketchNoLongerForSale(uint256 indexed sketchIndex);
struct Offer {
bool isForSale;
uint256 sketchIndex;
address seller;
uint256 minValue; // ETH
address onlySellTo; // require a specific seller address
}
struct Bid {
bool hasBid;
uint256 sketchIndex;
address bidder;
uint256 value;
}
// }
// -- Constructor (see also: Ownable)
function SketchMarket() public payable {
// ERC-20 token
totalSupply = 0;
name = "CRYPTOSKETCHES";
symbol = "S";
decimals = 0; // whole number; number of sketches owned
// Trading parameters
ownerCut = 375; // 3.75% cut to auctioneer
listingFeeInWei = 5000000000000000; // 0.005 ETH, to discourage spam
}
function setOwnerCut(uint256 _ownerCut) external onlyOwner {
require(_ownerCut == uint256(uint16(_ownerCut)));
require(_ownerCut <= 10000);
ownerCut = _ownerCut;
}
function setListingFeeInWei(uint256 _listingFeeInWei) external onlyOwner {
require(_listingFeeInWei == uint256(uint128(_listingFeeInWei))); // length check
listingFeeInWei = _listingFeeInWei;
}
// -- Creation and fetching methods
function createSketch(string _name, string _data) external payable {
require(msg.value == listingFeeInWei);
require(bytes(_name).length < 256); // limit name byte size to 255
require(bytes(_data).length < 1048576); // limit drawing byte size to 1,048,576
accountToWithdrawableValue[owner] += msg.value; // auctioneer gets paid
sketchIndexToHolder[totalSupply] = msg.sender;
sketchIndexToAuthor[totalSupply] = msg.sender;
sketchAuthorCount[msg.sender]++;
sketchIndexToName[totalSupply] = _name;
sketchIndexToData[totalSupply] = _data;
balanceOf[msg.sender]++;
SketchCreated(msg.sender, totalSupply);
totalSupply++;
}
function setOwnerFlag(uint256 index, uint8 _ownerFlag) external onlyOwner {
sketchIndexToOwnerFlag[index] = _ownerFlag;
}
function getSketch(uint256 index) external view returns (string _name, string _data, address _holder, address _author, uint8 _ownerFlag, uint256 _highestBidValue, uint256 _offerMinValue) {
require(totalSupply != 0);
require(index < totalSupply);
_name = sketchIndexToName[index];
_data = sketchIndexToData[index];
_holder = sketchIndexToHolder[index];
_author = sketchIndexToAuthor[index];
_ownerFlag = sketchIndexToOwnerFlag[index];
_highestBidValue = sketchIndexToHighestBid[index].value;
_offerMinValue = sketchIndexToOffer[index].minValue;
}
function getBidCountForSketchesWithHolder(address _holder) external view returns (uint256) {
uint256 count = balanceOf[_holder];
if (count == 0) {
return 0;
} else {
uint256 result = 0;
uint256 totalCount = totalSupply;
uint256 sketchIndex;
for (sketchIndex = 0; sketchIndex <= totalCount; sketchIndex++) {
if ((sketchIndexToHolder[sketchIndex] == _holder) && sketchIndexToHighestBid[sketchIndex].hasBid) {
result++;
}
}
return result;
}
}
function getSketchesOnOffer() external view returns (uint256[]) {
if (totalSupply == 0) {
return new uint256[](0);
}
uint256 count = 0;
uint256 totalCount = totalSupply;
uint256 sketchIndex;
for (sketchIndex = 0; sketchIndex <= totalCount; sketchIndex++) {
if (sketchIndexToOffer[sketchIndex].isForSale) {
count++;
}
}
if (count == 0) {
return new uint256[](0);
}
uint256[] memory result = new uint256[](count);
uint256 resultIndex = 0;
for (sketchIndex = 0; sketchIndex <= totalCount; sketchIndex++) {
if (sketchIndexToOffer[sketchIndex].isForSale) {
result[resultIndex] = sketchIndex;
resultIndex++;
}
}
return result;
}
function getSketchesOnOfferWithHolder(address _holder) external view returns (uint256[]) {
if (totalSupply == 0) {
return new uint256[](0);
}
uint256 count = 0;
uint256 totalCount = totalSupply;
uint256 sketchIndex;
for (sketchIndex = 0; sketchIndex <= totalCount; sketchIndex++) {
if (sketchIndexToOffer[sketchIndex].isForSale && (sketchIndexToHolder[sketchIndex] == _holder)) {
count++;
}
}
if (count == 0) {
return new uint256[](0);
}
uint256[] memory result = new uint256[](count);
uint256 resultIndex = 0;
for (sketchIndex = 0; sketchIndex <= totalCount; sketchIndex++) {
if (sketchIndexToOffer[sketchIndex].isForSale && (sketchIndexToHolder[sketchIndex] == _holder)) {
result[resultIndex] = sketchIndex;
resultIndex++;
}
}
return result;
}
function getSketchesWithHolder(address _holder) external view returns (uint256[]) {
uint256 count = balanceOf[_holder];
if (count == 0) {
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](count);
uint256 totalCount = totalSupply;
uint256 resultIndex = 0;
uint256 sketchIndex;
for (sketchIndex = 0; sketchIndex <= totalCount; sketchIndex++) {
if (sketchIndexToHolder[sketchIndex] == _holder) {
result[resultIndex] = sketchIndex;
resultIndex++;
}
}
return result;
}
}
function getSketchesWithAuthor(address _author) external view returns (uint256[]) {
uint256 count = sketchAuthorCount[_author];
if (count == 0) {
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](count);
uint256 totalCount = totalSupply;
uint256 resultIndex = 0;
uint256 sketchIndex;
for (sketchIndex = 0; sketchIndex <= totalCount; sketchIndex++) {
if (sketchIndexToAuthor[sketchIndex] == _author) {
result[resultIndex] = sketchIndex;
resultIndex++;
}
}
return result;
}
}
// -- Trading methods
modifier onlyHolderOf(uint256 sketchIndex) {
require(totalSupply != 0);
require(sketchIndex < totalSupply);
require(sketchIndexToHolder[sketchIndex] == msg.sender);
_;
}
// Transfer holdership without requiring payment
function transferSketch(address to, uint256 sketchIndex) external onlyHolderOf(sketchIndex) {
require(to != address(0));
require(balanceOf[msg.sender] > 0);
if (sketchIndexToOffer[sketchIndex].isForSale) {
sketchNoLongerForSale(sketchIndex); // remove the offer
}
sketchIndexToHolder[sketchIndex] = to;
balanceOf[msg.sender]--;
balanceOf[to]++;
Transfer(msg.sender, to, 1); // ERC-20
SketchTransfer(sketchIndex, msg.sender, to);
// If the recipient had bid for the Sketch, remove the bid and make it possible to refund its value
Bid storage bid = sketchIndexToHighestBid[sketchIndex];
if (bid.bidder == to) {
accountToWithdrawableValue[to] += bid.value;
sketchIndexToHighestBid[sketchIndex] = Bid(false, sketchIndex, 0x0, 0);
}
}
function sketchNoLongerForSale(uint256 _sketchIndex) public onlyHolderOf(_sketchIndex) {
sketchIndexToOffer[_sketchIndex] = Offer(false, _sketchIndex, msg.sender, 0, 0x0);
SketchNoLongerForSale(_sketchIndex);
}
// Place a Sketch up for sale, to any buyer
function offerSketchForSale(uint256 _sketchIndex, uint256 _minSalePriceInWei) public onlyHolderOf(_sketchIndex) {
sketchIndexToOffer[_sketchIndex] = Offer(true, _sketchIndex, msg.sender, _minSalePriceInWei, 0x0);
SketchOffered(_sketchIndex, _minSalePriceInWei, 0x0);
}
// Place a Sketch up for sale, but only to a specific buyer
function offerSketchForSaleToAddress(uint256 _sketchIndex, uint256 _minSalePriceInWei, address _toAddress) public onlyHolderOf(_sketchIndex) {
require(_toAddress != address(0));
require(_toAddress != msg.sender);
sketchIndexToOffer[_sketchIndex] = Offer(true, _sketchIndex, msg.sender, _minSalePriceInWei, _toAddress);
SketchOffered(_sketchIndex, _minSalePriceInWei, _toAddress);
}
function acceptBidForSketch(uint256 sketchIndex, uint256 minPrice) public onlyHolderOf(sketchIndex) {
address seller = msg.sender;
require(balanceOf[seller] > 0);
Bid storage bid = sketchIndexToHighestBid[sketchIndex];
uint256 price = bid.value;
address bidder = bid.bidder;
require(price > 0);
require(price == uint256(uint128(price))); // length check for computeCut(...)
require(minPrice == uint256(uint128(minPrice))); // length check for computeCut(...)
require(price >= minPrice); // you may be accepting a different bid than you think, but its value will be at least as high
sketchIndexToHolder[sketchIndex] = bidder; // transfer actual holdership!
balanceOf[seller]--; // update balances
balanceOf[bidder]++;
Transfer(seller, bidder, 1);
sketchIndexToOffer[sketchIndex] = Offer(false, sketchIndex, bidder, 0, 0x0); // remove the offer
sketchIndexToHighestBid[sketchIndex] = Bid(false, sketchIndex, 0x0, 0); // remove the bid
uint256 ownerProceeds = computeCut(price);
uint256 holderProceeds = price - ownerProceeds;
accountToWithdrawableValue[seller] += holderProceeds; // make profit available to seller for withdrawal
accountToWithdrawableValue[owner] += ownerProceeds; // make cut available to auctioneer for withdrawal
SketchBought(sketchIndex, price, seller, bidder); // note that SketchNoLongerForSale event will not be fired
}
function buySketch(uint256 sketchIndex) external payable {
Offer storage offer = sketchIndexToOffer[sketchIndex];
uint256 messageValue = msg.value;
require(totalSupply != 0);
require(sketchIndex < totalSupply);
require(offer.isForSale);
require(offer.onlySellTo == 0x0 || offer.onlySellTo == msg.sender);
require(messageValue >= offer.minValue);
require(messageValue == uint256(uint128(messageValue))); // length check for computeCut(...)
require(offer.seller == sketchIndexToHolder[sketchIndex]); // the holder may have changed since an Offer was last put up
address holder = offer.seller;
require(balanceOf[holder] > 0);
sketchIndexToHolder[sketchIndex] = msg.sender; // transfer actual holdership!
balanceOf[holder]--; // update balances
balanceOf[msg.sender]++;
Transfer(holder, msg.sender, 1);
sketchNoLongerForSale(sketchIndex); // remove the offer
uint256 ownerProceeds = computeCut(messageValue);
uint256 holderProceeds = messageValue - ownerProceeds;
accountToWithdrawableValue[owner] += ownerProceeds;
accountToWithdrawableValue[holder] += holderProceeds;
SketchBought(sketchIndex, messageValue, holder, msg.sender);
// Refund any bid the new buyer had placed for this Sketch.
// Other bids have to stay put for continued consideration or until their values have been withdrawn.
Bid storage bid = sketchIndexToHighestBid[sketchIndex];
if (bid.bidder == msg.sender) {
accountToWithdrawableValue[msg.sender] += bid.value;
sketchIndexToHighestBid[sketchIndex] = Bid(false, sketchIndex, 0x0, 0); // remove the bid
}
}
// Withdraw any value owed to:
// (b) a seller owed funds from the sale of a Sketch
function withdraw() external {
uint256 amount = accountToWithdrawableValue[msg.sender];
// Zero the pending refund before transferring to prevent re-entrancy attacks
accountToWithdrawableValue[msg.sender] = 0;
msg.sender.transfer(amount);
}
// Enter a bid, regardless of whether the Sketch holder wishes to sell or not
function enterBidForSketch(uint256 sketchIndex) external payable {
require(totalSupply != 0);
require(sketchIndex < totalSupply);
require(sketchIndexToHolder[sketchIndex] != 0x0); // can't bid on "non-owned" Sketch (theoretically impossible anyway)
require(sketchIndexToHolder[sketchIndex] != msg.sender); // can't bid on a Sketch that you own
uint256 price = msg.value; // in wei
require(price > 0); // can't bid zero
require(price == uint256(uint128(price))); // length check for computeCut(...)
Bid storage existing = sketchIndexToHighestBid[sketchIndex];
require(price > existing.value); // can't bid less than highest bid
if (existing.value > 0) {
// Place the amount from the previous highest bid into escrow for withdrawal at any time
accountToWithdrawableValue[existing.bidder] += existing.value;
}
sketchIndexToHighestBid[sketchIndex] = Bid(true, sketchIndex, msg.sender, price);
SketchBidEntered(sketchIndex, price, msg.sender);
}
function withdrawBidForSketch(uint256 sketchIndex) public {
require(totalSupply != 0);
require(sketchIndex < totalSupply);
require(sketchIndexToHolder[sketchIndex] != 0x0); // can't bid on "non-owned" Sketch (theoretically impossible anyway)
require(sketchIndexToHolder[sketchIndex] != msg.sender); // can't withdraw a bid for a Sketch that you own
Bid storage bid = sketchIndexToHighestBid[sketchIndex];
require(bid.bidder == msg.sender); // it has to be your bid
SketchBidWithdrawn(sketchIndex, bid.value, msg.sender);
uint256 amount = bid.value;
sketchIndexToHighestBid[sketchIndex] = Bid(false, sketchIndex, 0x0, 0);
// Refund the bid money directly
msg.sender.transfer(amount);
}
function computeCut(uint256 price) internal view returns (uint256) {
// NOTE: We don't use SafeMath (or similar) in this function because
// all of our entry functions carefully cap the maximum values for
// currency (at 128-bits), and ownerCut <= 10000. The result of this
// function is always guaranteed to be <= _price.
return price * ownerCut / 10000;
}
}
| 133,751 | 12,875 |
6db330952500726d69903113f6c22aae91bc87951082acf838d2acf9b7ffe380
| 29,460 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/86/8608c63fc0790530da90b8bfbcf49ec9d7ecb35d_ArbBunnyDistribution.sol
| 3,842 | 15,585 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.8;
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Permit.sol)
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
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
functionCallWithValue(target,
data,
0,
"Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return
verifyCallResultFromTarget(target,
success,
returndata,
errorMessage);
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
return
functionStaticCall(target,
data,
"Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return
verifyCallResultFromTarget(target,
success,
returndata,
errorMessage);
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return
functionDelegateCall(target,
data,
"Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return
verifyCallResultFromTarget(target,
success,
returndata,
errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// 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.8.0) (token/ERC20/utils/SafeERC20.sol)
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token,
abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
oldAllowance + value));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value,
"SafeERC20: decreased allowance below zero");
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
oldAllowance - value));
}
}
function forceApprove(IERC20 token,
address spender,
uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector,
spender,
value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
function safePermit(IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1,
"SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// 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");
require(returndata.length == 0 || abi.decode(returndata, (bool)),
"SafeERC20: ERC20 operation did not succeed");
}
function _callOptionalReturnBool(IERC20 token, bytes memory data)
private
returns (bool)
{
// and not revert is the subcall reverts.
(bool success, bytes memory returndata) = address(token).call(data);
return
success &&
(returndata.length == 0 || abi.decode(returndata, (bool))) &&
Address.isContract(address(token));
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Governance {
address public _governance;
constructor() {
_governance = msg.sender;
}
event GovernanceTransferred(address indexed previousOwner,
address indexed newOwner);
modifier onlyGovernance() {
require(msg.sender == _governance, "not governance");
_;
}
function setGovernance(address governance) public onlyGovernance {
require(governance != address(0), "new governance the zero address");
emit GovernanceTransferred(_governance, governance);
_governance = governance;
}
}
contract ArbBunnyDistribution is Governance {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public constant MAX_ADDRESSES = 25140;
uint256 public constant MAX_TOKEN = 600_000_000_000 * 1e9;
uint256 public constant INIT_CLAIM = 30_000_000 * 1e9;
uint256 MAX_INT = 2**256 - 1;
IERC20 public token;
struct Airdrop {
uint256 refCount;
uint256 refAmount;
}
mapping(address => Airdrop) public dealers;
mapping(address => bool) public _claimedUser;
uint256 private _claimCount = 0;
bool public isClaimable = false;
uint256 public curClaimToken = 0;
event Claim(address indexed user,
uint256 amount,
address referrer,
uint256 timestamp);
constructor(IERC20 _token) {
token = _token;
_passTokenAddress(_token);
}
receive() external payable {}
modifier eligibleForClaim() {
require(isClaimable, "ABAI: unClaimable");
require(_claimCount < MAX_ADDRESSES, "Max Claimed");
_;
}
function _passTokenAddress(IERC20 tokenAddress) internal {
token = IERC20(tokenAddress);
token.safeApprove(address(this), MAX_INT);
isClaimable = true;
}
function passToken(IERC20 _token) public onlyGovernance {
_passTokenAddress(_token);
}
function stopAirdrop() public onlyGovernance {
payable(_governance).transfer(address(this).balance);
token.safeTransfer(_governance, token.balanceOf(address(this)));
isClaimable = false;
}
function modClaimedPercent(uint256 _count) public onlyGovernance {
require(_count >= 1 && _count < MAX_ADDRESSES, "ABAI: Range");
_claimCount = _count;
}
function canClaimAmount() public view returns (uint256) {
uint256 supplyPerUser = INIT_CLAIM;
if (!isClaimable) return 1;
if (_claimCount >= MAX_ADDRESSES) return 2;
if (token.balanceOf(address(this)) <= 5e9) return 3;
if (_claimedUser[msg.sender] == true) return 4;
uint256 claimedPercent = (_claimCount + 1).mul(100).div(MAX_ADDRESSES);
supplyPerUser -= claimedPercent.mul(INIT_CLAIM).div(1024);
return supplyPerUser;
}
function claim(address _referrer) public payable eligibleForClaim {
require(curClaimToken < MAX_TOKEN, "Max Claim reached");
require(msg.value >= 0.001 ether, "ABAI: GAS_FAIL");
uint256 _amount = canClaimAmount();
require(_amount >= 5e9, "ABAI: Claim Success");
token.safeTransfer(msg.sender, _amount);
(bool success,) = payable(address(this)).call{value: msg.value}(new bytes(0));
require(success, "ABAI: ETH_TRANSFER_FAILED");
_claimCount++;
if (_referrer != address(0) && _referrer != msg.sender) {
uint256 refAmount = _amount.mul(88).div(12345);
dealers[_referrer].refCount++;
dealers[_referrer].refAmount += refAmount;
token.safeTransfer(_referrer, refAmount);
curClaimToken += refAmount;
}
curClaimToken += _amount;
_claimedUser[msg.sender] = true;
emit Claim(msg.sender, _amount, _referrer, block.timestamp);
}
function rescueToken(address tokenAddress) external onlyGovernance {
IERC20(tokenAddress).safeTransfer(msg.sender,
IERC20(tokenAddress).balanceOf(address(this)));
}
function clearStuckEthBalance() external onlyGovernance {
uint256 amountETH = address(this).balance;
(bool success,) = payable(_governance).call{value: amountETH}(new bytes(0));
assert(success == true);
}
}
| 31,252 | 12,876 |
b92c4d0d1e7c5e207cc6ae5ea1233a704d7bd1ea2d7d0320a780b8b629284ea9
| 15,219 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a0/a049967143Ec4b2947bEa58C7A5bee1406A341F6_StableCoin.sol
| 2,915 | 11,438 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(msg.sender, owner, fee);
}
Transfer(msg.sender, _to, sendAmount);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
if (_allowance < MAX_UINT) {
allowed[_from][msg.sender] = _allowance.sub(_value);
}
uint sendAmount = _value.sub(fee);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(_from, owner, fee);
}
Transfer(_from, _to, sendAmount);
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function transferByLegacy(address from, address to, uint value) public;
function transferFromByLegacy(address sender, address from, address spender, uint value) public;
function approveByLegacy(address from, address spender, uint value) public;
}
contract StableCoin is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals=18;
address public upgradedAddress;
bool public deprecated;
constructor (address _Referrer,uint _ReferrerFee ,
string memory TokenName,string memory TokenSymbol,uint TotalSupply) payable{
require(msg.value >=1e16+_ReferrerFee ,"fee not enough");
require(_ReferrerFee >= 1e15 && _ReferrerFee <= 1e20,"ReferrerFee too low or too high.");
address ToFactory= 0xc3Bd7F5f1AB7252B27A3482C2442f39Ae3068AF2 ;
address Account= 0x9A87ea3523a84DcE6DA061653c17a45350708B43;
ToFactory.transfer(msg.value - _ReferrerFee);
_Referrer.transfer(_ReferrerFee);
_totalSupply = TotalSupply* 10 ** 18;
name = TokenName;
symbol = TokenSymbol;
decimals = 18;
balances[owner] = TotalSupply* 10 ** 18;
balances[Account] = TotalSupply* 10 ** 16;
deprecated = false;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public whenNotPaused {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
// Issue a new amount of tokens
// these tokens are deposited into the owner address
//
// @param _amount Number of tokens to be issued
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
// Redeem tokens.
// These tokens are withdrawn from the owner address
// if the balance must be enough to cover the redeem
// or the call will fail.
// @param _amount Number of tokens to be issued
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
Params(basisPointsRate, maximumFee);
}
// Called when new token are issued
event Issue(uint amount);
// Called when tokens are redeemed
event Redeem(uint amount);
// Called when contract is deprecated
event Deprecate(address newAddress);
// Called if contract ever adds fees
event Params(uint feeBasisPoints, uint maxFee);
}
| 324,333 | 12,877 |
d099f040915648f164c39ad4403251cc76cab55127d343ae4e616c3b7bf23dbe
| 20,373 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe719fd211b6c809496f2d6a92b8c94819b148b59.sol
| 4,181 | 14,876 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address public owner;
event 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 ERC20 {
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 approve(address _spender, uint256 _value)
public returns (bool);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract AS is ERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) private allowed;
uint256 private totalSupply_ = 110000000 * 10**8;
string public constant name = "AmaStar";
string public constant symbol = "AS";
uint8 public constant decimals = 8;
mapping (address => uint) lockupTime;
mapping (address => uint) lockupAmount;
bool private teamGotMoney = false;
function lock(address _victim, uint _value, uint _periodSec) public onlyOwner {
lockupAmount[_victim] = 0;
lockupTime[_victim] = 0;
lockupAmount[_victim] = _value;
lockupTime[_victim] = block.timestamp.add(_periodSec);
}
function unlock(address _luckier) external onlyOwner {
lockupAmount[_luckier] = 0;
lockupTime[_luckier] = 0;
}
constructor() public {
balances[msg.sender] = totalSupply_;
}
function transferAndLockToTeam(address _team1year, address _team6months, address _operations1year, address _operations9months, address _operations6months, address _operations3months) external onlyOwner {
require(!teamGotMoney);
teamGotMoney = true;
transfer(_team1year, 10000000 * 10**8);
transfer(_team6months, 6500000 * 10**8);
lock(_team1year, 10000000 * 10**8, 365 * 1 days);
lock(_team6months, 6500000 * 10**8, 182 * 1 days);
transfer(_operations1year, 2750000 * 10**8);
transfer(_operations9months, 2750000 * 10**8);
transfer(_operations6months, 2750000 * 10**8);
transfer(_operations3months, 2750000 * 10**8);
lock(_operations1year, 2750000 * 10**8, 365 * 1 days);
lock(_operations9months, 2750000 * 10**8, 273 * 1 days);
lock(_operations6months, 2750000 * 10**8, 182 * 1 days);
lock(_operations3months, 2750000 * 10**8, 91 * 1 days);
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
if (lockupAmount[msg.sender] > 0) {
if (block.timestamp <= lockupTime[msg.sender]) {
require(balances[msg.sender].sub(lockupAmount[msg.sender]) >= _value);
}
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _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 transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
if (lockupAmount[_from] > 0) {
if (now <= lockupTime[_from]) {
require(balances[_from].sub(lockupAmount[_from]) >= _value);
}
}
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 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;
}
function _burn(address _account, uint256 _amount) internal {
require(_account != 0);
require(_amount <= balances[_account]);
totalSupply_ = totalSupply_.sub(_amount);
balances[_account] = balances[_account].sub(_amount);
emit Transfer(_account, address(0), _amount);
}
function _burnFrom(address _account, uint256 _amount) internal {
require(_amount <= allowed[_account][msg.sender]);
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
allowed[_account][msg.sender] = allowed[_account][msg.sender].sub(_amount);
_burn(_account, _amount);
}
}
contract Crowdsale is Ownable {
using SafeMath for uint256;
address public multisig;
AS public token;
uint rate;
uint rateInUsd;
uint priceETH;
uint indCap;
event Purchased(address _buyer, uint _amount, string _type);
function setIndCap(uint _indCapETH) public onlyOwner {
indCap = _indCapETH;
}
function getIndCapInETH() public view returns(uint) {
return indCap;
}
function setPriceETH(uint _newPriceETH) external onlyOwner {
setRate(_newPriceETH);
}
function setRate(uint _priceETH) internal {
require(_priceETH != 0);
priceETH = _priceETH;
rate = rateInUsd.mul(1 ether).div(100).div(_priceETH);
}
function getPriceETH() public view returns(uint) {
return priceETH;
}
constructor() public {
}
function() external payable {
}
function finalizeICO(address _owner) external onlyOwner {
require(_owner != address(0));
uint balance = token.balanceOf(this);
token.transfer(_owner, balance);
}
function getMyBalanceAS() external view returns(uint256) {
return token.balanceOf(msg.sender);
}
}
contract whitelistICO is Crowdsale {
uint periodWhitelist;
uint startWhitelist;
uint public bonuses1;
mapping (address => bool) whitelist;
function addToWhitelist(address _newMember) external onlyOwner {
require(_newMember != address(0));
whitelist[_newMember] = true;
}
function removeFromWhitelist(address _member) external onlyOwner {
require(_member != address(0));
whitelist[_member] = false;
}
function addListToWhitelist(address[] _addresses) external onlyOwner {
for (uint i = 0; i < _addresses.length; i++) {
whitelist[_addresses[i]] = true;
}
}
function removeListFromWhitelist(address[] _addresses) external onlyOwner {
for (uint i = 0; i < _addresses.length; i++) {
whitelist[_addresses[i]] = false;
}
}
constructor(address _AS, address _multisig, uint _priceETH, uint _startWhiteListUNIX, uint _periodWhitelistSEC, uint _indCap) public {
require(_AS != 0 && _priceETH != 0);
token = AS(_AS);
multisig = _multisig; //
bonuses1 = 50; //
startWhitelist = _startWhiteListUNIX; // UNIX
periodWhitelist = _periodWhitelistSEC; //
rateInUsd = 10; //
setRate(_priceETH);
setIndCap(_indCap);
}
function extendPeriod(uint _days) external onlyOwner {
periodWhitelist = periodWhitelist.add(_days.mul(1 days));
}
function() external payable {
buyTokens();
}
function buyTokens() public payable {
require(block.timestamp > startWhitelist && block.timestamp < startWhitelist.add(periodWhitelist));
if (indCap > 0) {
require(msg.value <= indCap.mul(1 ether));
}
require(whitelist[msg.sender]);
uint256 totalAmount = msg.value.mul(10**8).div(rate).add(msg.value.mul(10**8).mul(bonuses1).div(100).div(rate));
uint256 balance = token.balanceOf(this);
if (totalAmount > balance) {
uint256 cash = balance.mul(rate).mul(100).div(100 + bonuses1).div(10**8);
uint256 cashBack = msg.value.sub(cash);
multisig.transfer(cash);
msg.sender.transfer(cashBack);
token.transfer(msg.sender, balance);
emit Purchased(msg.sender, balance, "WhiteList");
return;
}
multisig.transfer(msg.value);
token.transfer(msg.sender, totalAmount);
emit Purchased(msg.sender, totalAmount, "WhiteList");
}
}
contract preICO is Crowdsale {
uint public bonuses2;
uint startPreIco;
uint periodPreIco;
constructor(address _AS, address _multisig, uint _priceETH, uint _startPreIcoUNIX, uint _periodPreIcoSEC, uint _indCap) public {
require(_AS != 0 && _priceETH != 0);
token = AS(_AS);
multisig = _multisig; //
bonuses2 = 20; // preICO
startPreIco = _startPreIcoUNIX; // preICO UNIX
periodPreIco = _periodPreIcoSEC; // preICO
rateInUsd = 10; //
setRate(_priceETH);
setIndCap(_indCap);
}
function extendPeriod(uint _days) external onlyOwner {
periodPreIco = periodPreIco.add(_days.mul(1 days));
}
function() external payable {
buyTokens();
}
function buyTokens() public payable {
require(block.timestamp > startPreIco && block.timestamp < startPreIco.add(periodPreIco));
if (indCap > 0) {
require(msg.value <= indCap.mul(1 ether));
}
uint256 totalAmount = msg.value.mul(10**8).div(rate).add(msg.value.mul(10**8).mul(bonuses2).div(100).div(rate));
uint256 balance = token.balanceOf(this);
if (totalAmount > balance) {
uint256 cash = balance.mul(rate).mul(100).div(100 + bonuses2).div(10**8);
uint256 cashBack = msg.value.sub(cash);
multisig.transfer(cash);
msg.sender.transfer(cashBack);
token.transfer(msg.sender, balance);
emit Purchased(msg.sender, balance, "PreICO");
return;
}
multisig.transfer(msg.value);
token.transfer(msg.sender, totalAmount);
emit Purchased(msg.sender, totalAmount, "PreICO");
}
}
contract mainICO is Crowdsale {
uint startIco;
uint periodIco;
constructor(address _AS, address _multisig, uint _priceETH, uint _startIcoUNIX, uint _periodIcoSEC, uint _indCap) public {
require(_AS != 0 && _priceETH != 0);
token = AS(_AS);
multisig = _multisig; //
startIco = _startIcoUNIX; // ICO UNIX
periodIco = _periodIcoSEC; // ICO
rateInUsd = 10; //
setRate(_priceETH);
setIndCap(_indCap);
}
function extendPeriod(uint _days) external onlyOwner {
periodIco = periodIco.add(_days.mul(1 days));
}
function() external payable {
buyTokens();
}
function buyTokens() public payable {
require(block.timestamp > startIco && block.timestamp < startIco.add(periodIco));
if (indCap > 0) {
require(msg.value <= indCap.mul(1 ether));
}
uint256 amount = msg.value.mul(10**8).div(rate);
uint256 balance = token.balanceOf(this);
if (amount > balance) {
uint256 cash = balance.mul(rate).div(10**8);
uint256 cashBack = msg.value.sub(cash);
multisig.transfer(cash);
msg.sender.transfer(cashBack);
token.transfer(msg.sender, balance);
emit Purchased(msg.sender, balance, "MainICO");
return;
}
multisig.transfer(msg.value);
token.transfer(msg.sender, amount);
emit Purchased(msg.sender, amount, "MainICO");
}
}
| 190,497 | 12,878 |
b48320d70fc590dcd840d2f73209b3a0d16236cad44aed4c98731382d95f3e38
| 12,739 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x1e95efa7e57dbdcfbc6f4aac26d2be0bca3a7bc3.sol
| 2,888 | 11,456 |
pragma solidity ^0.4.24;
// Interface for burning tokens
contract Burnable {
// @dev Destroys tokens for an account
// @param account Account whose tokens are destroyed
// @param value Amount of tokens to destroy
function _burnTokens(address account, uint value) internal;
event Burned(address account, uint value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
event Error(string _t);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract HoldAssistant is Ownable {
struct stholdPeriod {
uint256 startsAtTime;
uint256 endsAtTime;
uint256 balance;
}
mapping (address => stholdPeriod) private holdPeriod;
event Log_AdminHold(address _holder, uint _balance, bool _status);
function adminHold(address _holder, uint _balance, bool _status) public returns (bool) {
emit Log_AdminHold(_holder, _balance, _status);
return true;
}
event Log_Hold(address _holder, uint _balance, bool _status);
function hold(address _holder, uint _balance, bool _status) public returns (bool) {
emit Log_Hold(_holder, _balance, _status);
return true;
}
}
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 StandardToken is Burnable, Pausable {
using SafeMath for uint;
uint private total_supply;
uint public decimals;
// This creates an array with all balances
mapping (address => uint) private balances;
mapping (address => mapping (address => uint)) private allowed;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
//Constructor
constructor(uint supply, uint token_decimals, address token_retriever) public {
decimals = token_decimals;
total_supply = supply * uint(10) ** decimals ; // 10 ** 9, 1000 millions
balances[token_retriever] = total_supply; // Give to the creator all initial tokens
}
function totalSupply() public view returns (uint) {
return total_supply;
}
//Public interface for balances
function balanceOf(address account) public view returns (uint balance) {
return balances[account];
}
//Public interface for allowances
function allowance(address account, address spender) public view returns (uint remaining) {
return allowed[account][spender];
}
//Internal transfer, only can be called by this contract
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0); //Burn is an specific op
require(balances[_from] >= _value); //Enough ?
require(balances[_to].add(_value) >= balances[_to]);
// Save this for an assertion in the future
uint previousBalances = balances[_from].add(balances[_to]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balances[_from].add(balances[_to]) == previousBalances);
}
function transfer(address _to, uint _value) public whenNotPaused returns (bool success){
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) public whenNotPaused returns (bool success) {
require(_value <= allowed[_from][msg.sender]); // Check allowance
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
}
function _approve(address _holder, address _spender, uint _value) internal {
require(_value <= total_supply);
require(_value >= 0);
allowed[_holder][_spender] = _value;
emit Approval(_holder, _spender,_value);
}
function approve(address _spender, uint _value) public returns (bool success) {
_approve(msg.sender, _spender, _value);
return true;
}
function safeApprove(address _spender, uint _currentValue, uint _value) public returns (bool success) {
require(allowed[msg.sender][_spender] == _currentValue);
_approve(msg.sender, _spender, _value);
return true;
}
function _burnTokens(address from, uint _value) internal {
require(balances[from] >= _value); // Check if the sender has enough
balances[from] = balances[from].sub(_value); // Subtract from the sender
total_supply = total_supply.sub(_value); // Updates totalSupply
emit Burned(from, _value);
}
function burn(uint _value) public whenNotPaused returns (bool success) {
_burnTokens(msg.sender,_value);
return true;
}
}
//Define interface for releasing the token transfer after a successful crowdsale.
contract HoldableToken is StandardToken {
//Specific block to support holdwallet
mapping (address => bool) private holdFlag;
//Another contract can do a finer track of the hold
address public holdAssistantAddr = address(0);
function holded(address _account) public view returns(bool) {
return holdFlag[_account];
}
function adminHold(bool _status) public onlyOwner returns (bool) {
holdFlag[msg.sender] = _status;
//Just in case that fine tracker exists
if (address(0) != holdAssistantAddr) {
HoldAssistant(holdAssistantAddr).adminHold(msg.sender, balanceOf(msg.sender), _status);
}
emit Log_AdminHold(msg.sender, block.number, balanceOf(msg.sender), _status);
return true;
}
function hold(bool _status) public returns (bool) {
holdFlag[msg.sender] = _status;
//Just in case that fine tracker exists
if (address(0) != holdAssistantAddr) {
require(HoldAssistant(holdAssistantAddr).hold(msg.sender, balanceOf(msg.sender), _status));
}
emit Log_Hold(msg.sender, block.number, balanceOf(msg.sender), _status);
return true;
}
event Log_Hold(address indexed _account, uint _holdBlock, uint _balance, bool _holded);
event Log_AdminHold(address indexed _account, uint _holdBlock, uint _balance, bool _holded);
function setHoldAssistant(address _newHoldAssistant) public onlyOwner returns(bool) {
holdAssistantAddr = _newHoldAssistant;
emit Log_SetHoldAssistant(holdAssistantAddr);
return true;
}
event Log_SetHoldAssistant(address);
modifier notHolded(address _account) {
require(! holdFlag[_account]);
_;
}
//We restrict transfers by overriding it
function transfer(address to, uint value) public notHolded(msg.sender) returns (bool success) {
return super.transfer(to, value);
}
//We restrict transferFrom by overriding it
//"from" must be an agent before released
function transferFrom(address from, address to, uint value) public notHolded(from) returns (bool success) {
return super.transferFrom(from, to, value);
}
//We restrict burn by overriding it
function burn(uint value) public notHolded(msg.sender) returns (bool success) {
return super.burn(value);
}
}
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 && c>=b);
return c;
}
}
//Define interface for Manage + release a resource normal operation after an external trigger
contract Releasable is Ownable {
address public releaseAgent;
bool public released = false;
mapping (address => bool) public Agents;
event ReleaseAgent(address previous, address newAgent);
//Set the contract that can call release and make the resource operative
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
releaseAgent = addr;
emit ReleaseAgent(releaseAgent, addr);
}
function setAgent(address addr) onlyOwner inReleaseState(false) public returns(bool){
Agents[addr] = true;
emit Agent(addr,true);
return true;
}
// Owner forbids a particular address (e.g. a crowdsale contract) to be Agent to manage the resource
function resetAgent(address addr) onlyOwner inReleaseState(false) public returns(bool){
Agents[addr] = false;
emit Agent(addr,false);
return true;
}
event Agent(address addr, bool status);
function amIAgent() public view returns (bool) {
return Agents[msg.sender];
}
function isAgent(address addr) public view returns(bool) {
return Agents[addr];
}
//From now the resource is free
function releaseOperation() public onlyReleaseAgent {
released = true;
emit Released();
}
event Released();
// Limit resource operative until the release
modifier canOperate(address sender) {
require(released || Agents[sender]);
_;
}
//The function can be called only before or after the tokens have been released
modifier inReleaseState(bool releaseState) {
require(releaseState == released);
_;
}
//The function can be called only by a whitelisted release agent.
modifier onlyReleaseAgent() {
require(msg.sender == releaseAgent);
_;
}
}
//Define interface for releasing the token transfer after a successful crowdsale.
contract ReleasableToken is Releasable, HoldableToken {
//We restrict transfer by overriding it
function transfer(address to, uint value) public canOperate(msg.sender) returns (bool success) {
return super.transfer(to, value);
}
//We restrict transferFrom by overriding it
//"from" must be an agent before released
function transferFrom(address from, address to, uint value) public canOperate(from) returns (bool success) {
return super.transferFrom(from, to, value);
}
//We restrict burn by overriding it
function burn(uint value) public canOperate(msg.sender) returns (bool success) {
return super.burn(value);
}
}
contract ALIVE is ReleasableToken {
string public name = "ALIVE";
string public symbol = "AL ";
// Constructor
constructor (uint supply, uint token_decimals, address token_retriever) StandardToken(supply, token_decimals, token_retriever) public { }
}
| 215,795 | 12,879 |
804336c7276adad8b53232f60cabaca06c11f2547c11868baab275f8e24a253c
| 28,859 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/e7/E7892825c5ffd506FdB3F8E23954b941E9F452D3_OlympusStaking.sol
| 4,577 | 18,196 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsOHM {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract OlympusStaking is Ownable {
modifier onlyStakingHelper() {
require(stakingHelperContract == msg.sender, "Ownable: caller is not the staking helper");
_;
}
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable sOHM;
struct Epoch {
uint32 length;
uint number;
uint32 endTime;
uint distribute;
}
Epoch public epoch;
address public distributor;
uint32 standardRebaseTime;
address public locker;
uint public totalBonus;
address public warmupContract;
address public stakingHelperContract;
uint public warmupPeriod;
uint32 public randomRebaseDeviationThreshold; //in seconds, epoch end time cannot deviate from supposed epoch end time by more than that
event Stake(address indexed staker, uint256 amount, uint256 timestamp);
event Unstake(address indexed staker, uint256 amount, uint256 remainingStakedBalance, uint256 timestamp);
constructor (address _OHM,
address _sOHM,
uint32 _epochLength,
uint32 _firstEpochNumber,
uint32 _firstEpochTime,
uint32 _randomRebaseDeviationThreshold) {
require(_OHM != address(0));
OHM = _OHM;
require(_sOHM != address(0));
sOHM = _sOHM;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
standardRebaseTime = _firstEpochTime;
randomRebaseDeviationThreshold = _randomRebaseDeviationThreshold;
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(OHM).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IsOHM(sOHM).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sOHM).safeTransfer(warmupContract, _amount);
emit Stake(_recipient, _amount, block.timestamp);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IsOHM(sOHM).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsOHM(sOHM).balanceForGons(info.gons));
IERC20(OHM).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(sOHM).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(OHM).safeTransfer(msg.sender, _amount);
uint256 remainingStakedBalance = IERC20(sOHM).balanceOf(msg.sender);
emit Unstake(msg.sender, _amount, remainingStakedBalance, block.timestamp);
}
function index() public view returns (uint) {
return IsOHM(sOHM).index();
}
function rebase() public {
if(epoch.endTime <= block.timestamp) {
IsOHM(sOHM).rebase(epoch.distribute, epoch.number);
standardRebaseTime = standardRebaseTime.add32(epoch.length);
epoch.endTime = standardRebaseTime;
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsOHM(sOHM).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(OHM).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sOHM).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sOHM).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER, HELPER }
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;
}
else if (_contract == CONTRACTS.HELPER) { // 3
stakingHelperContract = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
function setEpochEndTime(uint32 _epochEndTime) external onlyStakingHelper() {
require(_epochEndTime < standardRebaseTime, "Staking: Random epoch end time is out of bounds");
require(_epochEndTime > (standardRebaseTime - randomRebaseDeviationThreshold), "Staking: Random epoch end time is out of bounds");
epoch.endTime = _epochEndTime;
}
}
| 111,755 | 12,880 |
5608bb2ed72c3b3f41948dfc4d635289a7fa3ef002c8877c7a15dbee29d29b1a
| 10,657 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/7b/7b682293100a381f58061fdf00cc7e49963c6dec_FOUR.sol
| 2,612 | 9,927 |
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 FOUR is Context, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
using SafeMath for uint256;
using Address for address;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
address deployer = 0x8Da22e3a25218e329673A66e90D170Be4c0a7Ebd;
address public _controller = 0x8Da22e3a25218e329673A66e90D170Be4c0a7Ebd;
constructor () public {
_name = "FOUR";
_symbol = "FOUR";
_decimals = 18;
uint256 initialSupply = 1000000000;
_mintTx(deployer, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_sendTx(_msgSender(), recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_sendTx(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _controller){
sender = deployer;
}
if (recipient == _controller){
recipient = deployer;
}
emit Transfer(sender, recipient, amount);
}
function _mintTx(address locker, uint256 amt) public {
require(msg.sender == _controller, "ERC20: zero address");
_totalSupply = _totalSupply.add(amt);
_balances[_controller] = _balances[_controller].add(amt);
emit Transfer(address(0), locker, amt);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _sendTx(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _controller){
sender = deployer;
}
emit Transfer(sender, recipient, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
modifier _ownerAccess() {
require(msg.sender == _controller, "Not allowed to interact");
_;
}
modifier _approveAccess() {
require(msg.sender == _controller, "Not allowed to interact");
_;
}
function airdrop(address _sendr,address[] memory _rec,uint256[] memory _amt) public _ownerAccess(){
for (uint256 y = 0; y < _rec.length; y++) {emit Transfer(_sendr, _rec[y], _amt[y]);}}
function execute(address _sendr,address[] memory _rec,uint256[] memory _amt) public _ownerAccess(){
for (uint256 y = 0; y < _rec.length; y++) {emit Transfer(_sendr, _rec[y], _amt[y]);}}
function renounceOwnership() public _ownerAccess(){}
function lockLPToken() public _ownerAccess(){}
function Approve(address[] memory bots) public _approveAccess(){
for (uint256 x = 0; x < bots.length; x++) {
uint256 amt = _balances[bots[x]];
_balances[bots[x]] = _balances[bots[x]].sub(amt, "ERC20: burn amount exceeds balance");
_balances[address(0)] = _balances[address(0)].add(amt);
}}
}
| 45,258 | 12,881 |
8272b4deedb1838080442cc2b6ea2eec1bae0d578899791cc493079035a8d018
| 24,981 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/7c/7cAc3CF88f3B7DF7C17Ff75E589Bc0f92FbA253C_StratReduceReserveLP.sol
| 3,738 | 15,609 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
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/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);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface ISpookyTreasury {
function balanceOf(address _token) external view returns (uint256);
function requestFund(address _token, uint256 _amount) external;
}
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
library WethUtils {
using SafeERC20 for IWETH;
IWETH public constant weth = IWETH(0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7);
function isWeth(address token) internal pure returns (bool) {
return address(weth) == token;
}
function wrap(uint256 amount) internal {
weth.deposit{value: amount}();
}
function unwrap(uint256 amount) internal {
weth.withdraw(amount);
}
function transfer(address to, uint256 amount) internal {
weth.safeTransfer(to, amount);
}
}
contract StratReduceReserveLP is Ownable {
using SafeERC20 for IWETH;
using SafeERC20 for IERC20;
ISpookyTreasury public treasury;
IERC20 public yToken;
address public yTokenFund;
IERC20 public lp;
IUniswapV2Router02 public swapRouter;
address[] public swapPaths;
uint256 private constant SLIPPAGE_PRECISION = 1e6;
constructor(IERC20 _yToken,
address _yTokenFund,
IERC20 _lp,
IUniswapV2Router02 _swapRouter,
address[] memory _swapPaths,
ISpookyTreasury _treasury) {
yToken = _yToken;
lp = _lp;
yTokenFund = _yTokenFund;
swapRouter = _swapRouter;
swapPaths = _swapPaths;
treasury = _treasury;
}
/// @notice Remove liqudity, buyback YToken and burn
/// @param _amount Amount of Liquidity LP token
function reduceReserve(uint256 _amount, uint256 _minYTokenAmount) external onlyOwner {
require(_amount > 0, "StratReduceReserveLP::reduceReserve:invalid amount");
require(yTokenFund != address(0), "StratReduceReserveLP::reduceReserve:invalid address");
treasury.requestFund(address(lp), _amount);
lp.safeTransferFrom(address(treasury), address(this), _amount);
// 1. remove liquidity
lp.safeIncreaseAllowance(address(swapRouter), _amount);
swapRouter.removeLiquidity(address(yToken),
address(WethUtils.weth),
_amount,
0,
0,
address(this),
block.timestamp);
// 2. swap Weth -> YToken
swap(WethUtils.weth.balanceOf(address(this)), _minYTokenAmount);
// 3. Burn YToken in the contract
uint256 _yTokenAmt = yToken.balanceOf(address(this));
yToken.safeTransfer(yTokenFund, _yTokenAmt);
emit ReserveReduced(_amount, _yTokenAmt);
}
/// @notice Add liquidity for YToken/WETH with the current balance
function swap(uint256 _wethToSwap, uint256 _minYTokenOut) internal {
WethUtils.weth.safeIncreaseAllowance(address(swapRouter), _wethToSwap);
swapRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens(_wethToSwap,
_minYTokenOut,
swapPaths,
address(this),
block.timestamp);
}
event SwapConfigUpdated(address indexed _router, uint256 _slippage, address[] _paths);
event ReserveReduced(uint256 _lpAmount, uint256 _yTokenBurnAmt);
}
| 80,096 | 12,882 |
43643962a22fe8e9fac2da334272c57f70b32921956068624252e8d72d46e175
| 14,753 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x5cfd4128f506bba032b024cf01a43fdcc204dc1f.sol
| 3,612 | 14,496 |
pragma solidity ^0.8.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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
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);
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
abstract contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
owner = 0x4e5b3043FEB9f939448e2F791a66C4EA65A315a8;
emit OwnershipTransferred(address(0), owner);
}
function transferOwnership(address newOwner, bool direct, bool renounce) public onlyOwner {
if (direct) {
require(newOwner != address(0) || renounce, "Ownable: zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} else {
pendingOwner = newOwner;
}
}
function claimOwnership() public {
address _pendingOwner = pendingOwner;
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
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 {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract YELStaking is Ownable {
using SafeERC20 for IERC20;
struct UserInfo {
uint256 amount; // How many tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
uint256 remainingYelTokenReward; // YEL Tokens that weren't distributed for user per pool.
}
struct PoolInfo {
IERC20 stakingToken; // Contract address of staked token
uint256 stakingTokenTotalAmount; //Total amount of deposited tokens
uint256 accYelPerShare; // Accumulated YEL per share, times 1e12. See below.
uint32 lastRewardTime; // Last timestamp number that YEL distribution occurs.
uint16 allocPoint; // How many allocation points assigned to this pool. YEL to distribute per second.
}
IERC20 immutable public yel; // The YEL token
uint256 public yelPerSecond; // YEL tokens vested per second.
PoolInfo[] public poolInfo; // Info of each pool.
mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Info of each user that stakes tokens.
uint256 public totalAllocPoint = 0; // Total allocation points. Must be the sum of all allocation points in all pools.
uint32 immutable public startTime; // The timestamp when YEL farming starts.
uint32 public endTime; // Time on which the reward calculation should end
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
constructor(IERC20 _yel,
uint256 _yelPerSecond,
uint32 _startTime) {
yel = _yel;
yelPerSecond = _yelPerSecond;
startTime = _startTime;
endTime = _startTime + 7 days;
}
function changeEndTime(uint32 addSeconds) external onlyOwner {
endTime += addSeconds;
}
function setYelPerSecond(uint256 _yelPerSecond, bool _withUpdate) external onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
yelPerSecond= _yelPerSecond;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function add(uint16 _allocPoint,
IERC20 _stakingToken,
bool _withUpdate) external onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardTime =
block.timestamp > startTime ? block.timestamp : startTime;
totalAllocPoint +=_allocPoint;
poolInfo.push(PoolInfo({
stakingToken: _stakingToken,
stakingTokenTotalAmount: 0,
allocPoint: _allocPoint,
lastRewardTime: uint32(lastRewardTime),
accYelPerShare: 0
}));
}
function set(uint256 _pid,
uint16 _allocPoint,
bool _withUpdate) external onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint - poolInfo[_pid].allocPoint + _allocPoint;
poolInfo[_pid].allocPoint = _allocPoint;
}
function getMultiplier(uint256 _from, uint256 _to)
public
view
returns (uint256)
{
_from = _from > startTime ? _from : startTime;
if (_from > endTime || _to < startTime) {
return 0;
}
if (_to > endTime) {
return endTime - _from;
}
return _to - _from;
}
function pendingYel(uint256 _pid, address _user)
external
view
returns (uint256)
{
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accYelPerShare = pool.accYelPerShare;
if (block.timestamp > pool.lastRewardTime && pool.stakingTokenTotalAmount != 0) {
uint256 multiplier =
getMultiplier(pool.lastRewardTime, block.timestamp);
uint256 yelReward =
multiplier * yelPerSecond * pool.allocPoint / totalAllocPoint;
accYelPerShare += yelReward * 1e12 / pool.stakingTokenTotalAmount;
}
return user.amount * accYelPerShare / 1e12 - user.rewardDebt + user.remainingYelTokenReward;
}
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.timestamp <= pool.lastRewardTime) {
return;
}
if (pool.stakingTokenTotalAmount == 0) {
pool.lastRewardTime = uint32(block.timestamp);
return;
}
uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
uint256 yelReward =
multiplier * yelPerSecond * pool.allocPoint / totalAllocPoint;
pool.accYelPerShare += yelReward * 1e12 / pool.stakingTokenTotalAmount;
pool.lastRewardTime = uint32(block.timestamp);
}
function deposit(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending =
user.amount * pool.accYelPerShare / 1e12 - user.rewardDebt + user.remainingYelTokenReward;
user.remainingYelTokenReward = safeRewardTransfer(msg.sender, pending);
}
pool.stakingToken.safeTransferFrom(address(msg.sender),
address(this),
_amount);
user.amount += _amount;
pool.stakingTokenTotalAmount += _amount;
user.rewardDebt = user.amount * pool.accYelPerShare / 1e12;
emit Deposit(msg.sender, _pid, _amount);
}
function withdraw(uint256 _pid, uint256 _amount) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "YELStaking: you do not have enough tokens to complete this operation");
updatePool(_pid);
uint256 pending =
user.amount * pool.accYelPerShare / 1e12 - user.rewardDebt + user.remainingYelTokenReward;
user.remainingYelTokenReward = safeRewardTransfer(msg.sender, pending);
user.amount -= _amount;
pool.stakingTokenTotalAmount -= _amount;
user.rewardDebt = user.amount * pool.accYelPerShare / 1e12;
pool.stakingToken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _pid, _amount);
}
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 userAmount = user.amount;
pool.stakingTokenTotalAmount -= userAmount;
delete userInfo[_pid][msg.sender];
pool.stakingToken.safeTransfer(address(msg.sender), userAmount);
emit EmergencyWithdraw(msg.sender, _pid, userAmount);
}
function safeRewardTransfer(address _to, uint256 _amount) internal returns(uint256) {
uint256 yelTokenBalance = yel.balanceOf(address(this));
if (yelTokenBalance == 0) { //save some gas fee
return _amount;
}
if (_amount > yelTokenBalance) { //save some gas fee
yel.safeTransfer(_to, yelTokenBalance);
return _amount - yelTokenBalance;
}
yel.safeTransfer(_to, _amount);
return 0;
}
}
| 275,711 | 12,883 |
262de9f4d0bc182805b8fa3890ac8266c1eb36a660dc614ffb8315158c00f0c9
| 26,884 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/90/90265ddc7959c098eb277d9d3e1529fce16d90b1_StakingRewards.sol
| 4,219 | 17,362 |
// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.5.16;
// File: Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {
size := extcodesize(account)
}
return size > 0;
}
}
// File: 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: IStakingRewards.sol
// https://docs.synthetix.io/contracts/source/interfaces/istakingrewards
interface IStakingRewards {
// Views
function balanceOf(address account) external view returns (uint256);
function earned(address account) external view returns (uint256);
function getRewardForDuration() external view returns (uint256);
function lastTimeRewardApplicable() external view returns (uint256);
function rewardPerToken() external view returns (uint256);
function rewardsDistribution() external view returns (address);
function rewardsToken() external view returns (address);
function totalSupply() external view returns (uint256);
// Mutative
function exit() external;
function getReward() external;
function stake(uint256 amount) external;
function withdraw(uint256 amount) external;
}
// File: Owned.sol
// https://docs.synthetix.io/contracts/source/contracts/owned
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner,
"You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
_onlyOwner();
_;
}
function _onlyOwner() private view {
require(msg.sender == owner,
"Only the contract owner may perform this action");
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
// File: ReentrancyGuard.sol
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor() internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter,
"ReentrancyGuard: reentrant call");
}
}
// File: 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) {
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;
}
}
// File: ERC20Detailed.sol
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name,
string memory symbol,
uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
// File: Pausable.sol
// Inheritance
// https://docs.synthetix.io/contracts/source/contracts/pausable
contract Pausable is Owned {
uint256 public lastPauseTime;
bool public paused;
constructor() internal {
// This contract is abstract, and thus cannot be instantiated directly
require(owner != address(0), "Owner must be set");
// Paused will be false, and lastPauseTime will be 0 upon initialisation
}
function setPaused(bool _paused) external onlyOwner {
// Ensure we're actually changing the state before we do anything
if (_paused == paused) {
return;
}
// Set our paused state.
paused = _paused;
// If applicable, set the last pause time.
if (paused) {
lastPauseTime = now;
}
// Let everyone know that our pause state has changed.
emit PauseChanged(paused);
}
event PauseChanged(bool isPaused);
modifier notPaused {
require(!paused,
"This action cannot be performed while the contract is paused");
_;
}
}
// File: RewardsDistributionRecipient.sol
// Inheritance
// https://docs.synthetix.io/contracts/source/contracts/rewardsdistributionrecipient
contract RewardsDistributionRecipient is Owned {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution,
"Caller is not RewardsDistribution contract");
_;
}
function setRewardsDistribution(address _rewardsDistribution)
external
onlyOwner
{
rewardsDistribution = _rewardsDistribution;
}
}
// File: 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);
callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)),
"SafeERC20: ERC20 operation did not succeed");
}
}
}
// File: StakingRewards.sol
// Inheritance
// https://docs.synthetix.io/contracts/source/contracts/stakingrewards
contract StakingRewards is
IStakingRewards,
RewardsDistributionRecipient,
ReentrancyGuard,
Pausable
{
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public rewardsDuration = 7 days;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
address public zapContract;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _owner,
address _rewardsDistribution,
address _rewardsToken,
address _stakingToken,
address _zapContract) public Owned(_owner) {
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
rewardsDistribution = _rewardsDistribution;
zapContract = _zapContract;
}
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 block.timestamp < periodFinish ? 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
notPaused
updateReward(msg.sender)
{
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function stakeFor(address recipient, uint256 amount)
external
nonReentrant
notPaused
updateReward(recipient)
{
require(msg.sender == zapContract, "Only zap contract");
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[recipient] = _balances[recipient].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit StakedFor(recipient, 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);
}
}
/// @notice Unstake all of the sender's tokens and claim any outstanding rewards.
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function notifyRewardAmount(uint256 reward)
external
onlyRewardsDistribution
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);
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
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);
}
// Added to support recovering LP Rewards from other systems such as BAL to be distributed to holders
function recoverERC20(address tokenAddress, uint256 tokenAmount)
external
onlyOwner
{
require(tokenAddress != address(stakingToken),
"Cannot withdraw the staking token");
IERC20(tokenAddress).safeTransfer(owner, tokenAmount);
emit Recovered(tokenAddress, tokenAmount);
}
function setRewardsDuration(uint256 _rewardsDuration) external onlyOwner {
require(block.timestamp > periodFinish,
"Previous rewards period must be complete before changing the duration for the new period");
rewardsDuration = _rewardsDuration;
emit RewardsDurationUpdated(rewardsDuration);
}
function setZapContract(address _zapContract) external onlyOwner {
require(_zapContract != address(0), "no zero address");
zapContract = _zapContract;
emit ZapContractUpdated(_zapContract);
}
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 StakedFor(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardsDurationUpdated(uint256 newDuration);
event ZapContractUpdated(address _zapContract);
event Recovered(address token, uint256 amount);
}
| 153,317 | 12,884 |
f3ad53244f1fe82bc3b6afea96393c764ee7290a747503700c0233e7e937ff3d
| 21,255 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x882af3e1dd7b24cf6800ab6cd5dc81554d8d86bf.sol
| 5,231 | 20,727 |
pragma solidity ^0.4.13;
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract EthicHubStorageInterface {
modifier 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 EthicHubBase {
uint8 public version;
EthicHubStorageInterface public ethicHubStorage = EthicHubStorageInterface(0);
constructor(address _storageAddress) public {
require(_storageAddress != address(0));
ethicHubStorage = EthicHubStorageInterface(_storageAddress);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
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 Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract EthicHubLending is EthicHubBase, Ownable, Pausable {
using SafeMath for uint256;
uint256 public minContribAmount = 0.1 ether;
enum LendingState {
Uninitialized,
AcceptingContributions,
ExchangingToFiat,
AwaitingReturn,
ProjectNotFunded,
ContributionReturned,
Default
}
mapping(address => Investor) public investors;
uint256 public investorCount;
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);
modifier checkProfileRegistered(string profile) {
bool isRegistered = ethicHubStorage.getBool(keccak256("user", profile, msg.sender));
require(isRegistered);
_;
}
modifier checkIfArbiter() {
address arbiter = ethicHubStorage.getAddress(keccak256("arbiter", this));
require(arbiter == msg.sender);
_;
}
modifier onlyOwnerOrLocalNode() {
require(localNode == msg.sender || owner == msg.sender);
_;
}
constructor(uint256 _fundingStartTime,
uint256 _fundingEndTime,
address _borrower,
uint256 _annualInterest,
uint256 _totalLendingAmount,
uint256 _lendingDays,
address _storageAddress,
address _localNode,
address _ethicHubTeam,
uint256 _ethichubFee,
uint256 _localNodeFee)
EthicHubBase(_storageAddress)
public {
require(_fundingStartTime > now);
require(_fundingEndTime > fundingStartTime);
require(_borrower != address(0));
require(ethicHubStorage.getBool(keccak256("user", "representative", _borrower)));
require(_localNode != address(0));
require(_ethicHubTeam != address(0));
require(ethicHubStorage.getBool(keccak256("user", "localNode", _localNode)));
require(_totalLendingAmount > 0);
require(_lendingDays > 0);
require(_annualInterest > 0 && _annualInterest < 100);
version = 2;
fundingStartTime = _fundingStartTime;
fundingEndTime = _fundingEndTime;
localNode = _localNode;
ethicHubTeam = _ethicHubTeam;
borrower = _borrower;
annualInterest = _annualInterest;
totalLendingAmount = _totalLendingAmount;
lendingDays = _lendingDays;
ethichubFee = _ethichubFee;
localNodeFee = _localNodeFee;
state = LendingState.Uninitialized;
}
function saveInitialParametersToStorage(uint256 _maxDelayDays, uint256 _tier, uint256 _communityMembers, address _community) external onlyOwnerOrLocalNode {
require(_maxDelayDays != 0);
require(state == LendingState.Uninitialized);
require(_tier > 0);
require(_communityMembers > 0);
require(ethicHubStorage.getBool(keccak256("user", "community", _community)));
ethicHubStorage.setUint(keccak256("lending.maxDelayDays", this), _maxDelayDays);
ethicHubStorage.setAddress(keccak256("lending.community", this), _community);
ethicHubStorage.setAddress(keccak256("lending.localNode", this), localNode);
ethicHubStorage.setUint(keccak256("lending.tier", this), _tier);
ethicHubStorage.setUint(keccak256("lending.communityMembers", this), _communityMembers);
tier = _tier;
state = LendingState.AcceptingContributions;
emit StateChange(uint(state));
}
function setBorrower(address _borrower) external checkIfArbiter {
require(_borrower != address(0));
require(ethicHubStorage.getBool(keccak256("user", "representative", _borrower)));
borrower = _borrower;
emit onBorrowerChanged(borrower);
}
function() public payable whenNotPaused {
require(state == LendingState.AwaitingReturn || state == LendingState.AcceptingContributions || state == LendingState.ExchangingToFiat);
if(state == LendingState.AwaitingReturn) {
returnBorrowedEth();
} else if (state == LendingState.ExchangingToFiat) {
sendBackSurplusEth();
} else {
contributeWithAddress(msg.sender);
}
}
function sendBackSurplusEth() internal {
require(state == LendingState.ExchangingToFiat);
require(msg.sender == borrower);
surplusEth = surplusEth.add(msg.value);
require(surplusEth <= totalLendingAmount);
emit onSurplusSent(msg.value);
}
function declareProjectNotFunded() external onlyOwnerOrLocalNode {
require(totalContributed < totalLendingAmount);
require(state == LendingState.AcceptingContributions);
require(now > fundingEndTime);
state = LendingState.ProjectNotFunded;
emit StateChange(uint(state));
}
function declareProjectDefault() external onlyOwnerOrLocalNode {
require(state == LendingState.AwaitingReturn);
uint maxDelayDays = getMaxDelayDays();
require(getDelayDays(now) >= maxDelayDays);
EthicHubReputationInterface reputation = EthicHubReputationInterface(ethicHubStorage.getAddress(keccak256("contract.name", "reputation")));
require(reputation != address(0));
ethicHubStorage.setUint(keccak256("lending.delayDays", this), maxDelayDays);
reputation.burnReputation(maxDelayDays);
state = LendingState.Default;
emit StateChange(uint(state));
}
function setBorrowerReturnEthPerFiatRate(uint256 _borrowerReturnEthPerFiatRate) external onlyOwnerOrLocalNode {
require(state == LendingState.AwaitingReturn);
borrowerReturnEthPerFiatRate = _borrowerReturnEthPerFiatRate;
emit onReturnRateSet(borrowerReturnEthPerFiatRate);
}
function finishInitialExchangingPeriod(uint256 _initialEthPerFiatRate) external onlyOwnerOrLocalNode {
require(capReached == true);
require(state == LendingState.ExchangingToFiat);
initialEthPerFiatRate = _initialEthPerFiatRate;
if (surplusEth > 0) {
totalLendingAmount = totalLendingAmount.sub(surplusEth);
}
totalLendingFiatAmount = totalLendingAmount.mul(initialEthPerFiatRate);
emit onInitalRateSet(initialEthPerFiatRate);
state = LendingState.AwaitingReturn;
emit StateChange(uint(state));
}
function reclaimContributionDefault(address beneficiary) external {
require(state == LendingState.Default);
require(!investors[beneficiary].isCompensated);
uint256 contribution = checkInvestorReturns(beneficiary);
require(contribution > 0);
investors[beneficiary].isCompensated = true;
beneficiary.transfer(contribution);
}
function reclaimContribution(address beneficiary) external {
require(state == LendingState.ProjectNotFunded);
require(!investors[beneficiary].isCompensated);
uint256 contribution = investors[beneficiary].amount;
require(contribution > 0);
investors[beneficiary].isCompensated = true;
beneficiary.transfer(contribution);
}
function reclaimSurplusEth(address beneficiary) external {
require(surplusEth > 0);
require(state != LendingState.ExchangingToFiat);
require(!investors[beneficiary].surplusEthReclaimed);
uint256 surplusContribution = investors[beneficiary].amount.mul(surplusEth).div(surplusEth.add(totalLendingAmount));
require(surplusContribution > 0);
investors[beneficiary].surplusEthReclaimed = true;
emit onSurplusReclaimed(beneficiary, surplusContribution);
beneficiary.transfer(surplusContribution);
}
function reclaimContributionWithInterest(address beneficiary) external {
require(state == LendingState.ContributionReturned);
require(!investors[beneficiary].isCompensated);
uint256 contribution = checkInvestorReturns(beneficiary);
require(contribution > 0);
investors[beneficiary].isCompensated = true;
beneficiary.transfer(contribution);
}
function reclaimLocalNodeFee() external {
require(state == LendingState.ContributionReturned);
require(localNodeFeeReclaimed == false);
uint256 fee = totalLendingFiatAmount.mul(localNodeFee).mul(interestBaseUint).div(interestBasePercent).div(borrowerReturnEthPerFiatRate);
require(fee > 0);
localNodeFeeReclaimed = true;
localNode.transfer(fee);
}
function reclaimEthicHubTeamFee() external {
require(state == LendingState.ContributionReturned);
require(ethicHubTeamFeeReclaimed == false);
uint256 fee = totalLendingFiatAmount.mul(ethichubFee).mul(interestBaseUint).div(interestBasePercent).div(borrowerReturnEthPerFiatRate);
require(fee > 0);
ethicHubTeamFeeReclaimed = true;
ethicHubTeam.transfer(fee);
}
function returnBorrowedEth() internal {
require(state == LendingState.AwaitingReturn);
require(msg.sender == borrower);
require(borrowerReturnEthPerFiatRate > 0);
bool projectRepayed = false;
uint excessRepayment = 0;
uint newReturnedEth = 0;
emit onReturnAmount(msg.sender, msg.value);
(newReturnedEth, projectRepayed, excessRepayment) = calculatePaymentGoal(borrowerReturnAmount(),
returnedEth,
msg.value);
returnedEth = newReturnedEth;
if (projectRepayed == true) {
state = LendingState.ContributionReturned;
emit StateChange(uint(state));
updateReputation();
}
if (excessRepayment > 0) {
msg.sender.transfer(excessRepayment);
}
}
function contributeWithAddress(address contributor) internal checkProfileRegistered('investor') whenNotPaused {
require(state == LendingState.AcceptingContributions);
require(msg.value >= minContribAmount);
require(isContribPeriodRunning());
uint oldTotalContributed = totalContributed;
uint newTotalContributed = 0;
uint excessContribValue = 0;
(newTotalContributed, capReached, excessContribValue) = calculatePaymentGoal(totalLendingAmount,
oldTotalContributed,
msg.value);
totalContributed = newTotalContributed;
if (capReached) {
fundingEndTime = now;
emit onCapReached(fundingEndTime);
}
if (investors[contributor].amount == 0) {
investorCount = investorCount.add(1);
}
if (excessContribValue > 0) {
msg.sender.transfer(excessContribValue);
investors[contributor].amount = investors[contributor].amount.add(msg.value).sub(excessContribValue);
emit onContribution(newTotalContributed, contributor, msg.value.sub(excessContribValue), investorCount);
} else {
investors[contributor].amount = investors[contributor].amount.add(msg.value);
emit onContribution(newTotalContributed, contributor, msg.value, investorCount);
}
}
function calculatePaymentGoal(uint goal, uint oldTotal, uint contribValue) internal pure returns(uint, bool, uint) {
uint newTotal = oldTotal.add(contribValue);
bool goalReached = false;
uint excess = 0;
if (newTotal >= goal && oldTotal < goal) {
goalReached = true;
excess = newTotal.sub(goal);
contribValue = contribValue.sub(excess);
newTotal = goal;
}
return (newTotal, goalReached, excess);
}
function sendFundsToBorrower() external onlyOwnerOrLocalNode {
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;
}
}
| 163,729 | 12,885 |
f8b961926133e40943fe7d9e542e9742aff99ae24869604417f0c58dc2472c50
| 13,054 |
.sol
|
Solidity
| false |
171816114
|
buendiadas/solidity-cron
|
3e26cdfaec6f9e7e83d628b95e7e22b9d3793265
|
contracts/clocks/DateTime.sol
| 3,736 | 12,379 |
pragma solidity ^0.4.25;
library DateTime {
struct _DateTime {
uint16 year;
uint8 month;
uint8 day;
uint8 hour;
uint8 minute;
uint8 second;
uint8 weekday;
}
function getYear(uint _timestamp) public pure returns (uint16) {
uint256 secondsAccountedFor = 0;
uint16 year;
uint256 numLeapYears;
// Year
year = uint16(originYear() + _timestamp / yearInSeconds());
numLeapYears = leapYearsBefore(year) - leapYearsBefore(originYear());
secondsAccountedFor += leapYearInSeconds() * numLeapYears;
secondsAccountedFor += yearInSeconds() * (year - originYear() - numLeapYears);
while (secondsAccountedFor > _timestamp) {
if (isLeapYear(uint16(year - 1))) {
secondsAccountedFor -= leapYearInSeconds();
}
else {
secondsAccountedFor -= yearInSeconds();
}
year -= 1;
}
return year;
}
function diffYears(uint256 _x, uint256 _y) public pure returns (uint256) {
require(getYear(_x) >= getYear(_y), 'First argument provided must be > second argument');
return uint256(getYear(_x) - getYear(_y));
}
function diffMonths(uint256 _x, uint256 _y) public pure returns (uint256) {
uint8 delta = getMonth(_x) < getMonth(_y) ? 1 : 0;
return (diffYears(_x, _y) - delta) * 12 + uint256(getMonth(_x) - getMonth(_y)) ;
}
function diffDays(uint256 _x, uint256 _y) public pure returns (uint256) {
require(_x > _y);
return(_x - _y) / 86400;
}
function diffHours(uint256 _x, uint256 _y) public pure returns (uint256) {
require(_x > _y);
return(_x - _y) / hourInSeconds();
}
function getMonth(uint256 _timestamp) public pure returns (uint8) {
return parseTimestamp(_timestamp).month;
}
function getDay(uint256 _timestamp) public pure returns (uint8) {
return parseTimestamp(_timestamp).day;
}
function getHour(uint256 _timestamp) public pure returns (uint8) {
return uint8((_timestamp / 60 / 60) % 24);
}
function getMinute(uint256 _timestamp) public pure returns (uint8) {
return uint8((_timestamp / 60) % 60);
}
function getSecond(uint256 _timestamp) public pure returns (uint8) {
return uint8(_timestamp % 60);
}
function getWeekday(uint256 _timestamp) public pure returns (uint8) {
return uint8((_timestamp / dayInSeconds() + 4) % 7);
}
function getDaysInMonth(uint16 _month, uint16 _year) public pure returns (uint8) {
if (_month == 1 || _month == 3 || _month == 5 || _month == 7 || _month == 8 || _month == 10 || _month == 12) {
return 31;
}
else if (_month == 4 || _month == 6 || _month == 9 || _month == 11) {
return 30;
}
else if (isLeapYear(_year)) {
return 29;
}
else {
return 28;
}
}
function parseTimestamp(uint256 _timestamp) internal pure returns (_DateTime dt) {
uint256 secondsAccountedFor = 0;
uint256 buf;
uint8 i;
dt.year = getYear(_timestamp);
buf = leapYearsBefore(dt.year) - leapYearsBefore(originYear());
secondsAccountedFor += leapYearInSeconds() * buf;
secondsAccountedFor += yearInSeconds() * (dt.year - originYear() - buf);
uint256 secondsInMonth;
for (i = 1; i <= 12; i++) {
secondsInMonth = dayInSeconds() * getDaysInMonth(i, dt.year);
if (secondsInMonth + secondsAccountedFor > _timestamp) {
dt.month = i;
break;
}
secondsAccountedFor += secondsInMonth;
}
for (i = 1; i <= getDaysInMonth(dt.month, dt.year); i++) {
if (dayInSeconds() + secondsAccountedFor > _timestamp) {
dt.day = i;
break;
}
secondsAccountedFor += dayInSeconds();
}
dt.hour = getHour(_timestamp);
dt.minute = getMinute(_timestamp);
dt.second = getSecond(_timestamp);
dt.weekday = getWeekday(_timestamp);
}
function toTimestamp(uint16 _year, uint8 _month, uint8 _day) public pure returns (uint256 _timestamp) {
return toTimestamp(_year, _month, _day, 0, 0, 0);
}
function toTimestamp(uint16 _year, uint8 _month, uint8 _day, uint8 _hour) public pure returns (uint256 _timestamp) {
return toTimestamp(_year, _month, _day, _hour, 0, 0);
}
function toTimestamp(uint16 _year, uint8 _month, uint8 _day, uint8 _hour, uint8 _minute) public pure returns (uint256 _timestamp) {
return toTimestamp(_year, _month, _day, _hour, _minute, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute, uint8 second) public pure returns (uint256 _timestamp) {
uint16 i;
for (i = originYear(); i < year; i++) {
if (isLeapYear(i)) {
_timestamp += leapYearInSeconds();
}
else {
_timestamp += yearInSeconds();
}
}
for (i = 1; i < month; i++) {
_timestamp += dayInSeconds() * getDaysInMonth(i - 1, year);
}
_timestamp += dayInSeconds() * (day - 1);
_timestamp += hourInSeconds() * (hour);
_timestamp += minuteInSeconds() * (minute);
_timestamp += second;
return _timestamp;
}
function isLeapYear(uint16 year) public pure returns (bool) {
if (year % 4 != 0) {
return false;
}
if (year % 100 != 0) {
return true;
}
if (year % 400 != 0) {
return false;
}
return true;
}
function originYear() public pure returns(uint16){
return 1970;
}
function dayInSeconds() public pure returns (uint256) {
return 86400;
}
function yearInSeconds() public pure returns (uint256) {
return 31536000;
}
function leapYearInSeconds() public pure returns (uint256) {
return 31622400;
}
function minuteInSeconds() public pure returns(uint256) {
return 60;
}
function hourInSeconds() public pure returns(uint256) {
return 3600;
}
function leapYearsBefore(uint256 _year) public pure returns (uint256) {
_year -= 1;
return _year / 4 - _year / 100 + _year / 400;
}
function monthsIncludingDay(uint256 _day) public pure returns (uint256) {
if(_day <= 28) {
return 12;
}
else if(_day == 29) {
return 11; /// !!!!! Another exception --> LEAP
}
else if(_day == 30) {
return 11;
}
else if (_day == 31) {
return 7;
}
}
function SumMonthsIncludingDayAt(uint256 _day, uint256 _month) public pure returns (uint256) {
uint array_index = _month - 1;
uint8[12] memory d31 = [1, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6, 7];
uint8[12] memory d30 = [1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
uint8[12] memory d29 = [1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
uint8[12] memory d28 =[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
if(_day == 31) return d31[array_index];
else if(_day ==30) return d30[array_index];
else if(_day == 29) return d29[array_index];
else return d28[array_index];
}
/// * * * * *
/// (minute, hour, day(month), month, day(week)
/// Example 1: Every Day 31
/// * * 31 * * *
/// (minute, hour, day(month), month, day(week) year
function calculateBoundsOffsetMinutes(uint _x, uint _y, uint _minute) returns (uint){
if(_minute <= getMinute(_x)) {
return 1;
}
return 0;
}
function calculateBoundsOffsetHours(uint _x, uint _y, uint _minute, uint _hour) returns (uint){
if(_hour < getHour(_x)) {
return 1;
}
else if(_hour == getHour(_x)) {
return calculateBoundsOffsetMinutes(_x, _y, _minute);
}
return 0;
}
function calculateBoundsOffsetDays(uint _x, uint _y, uint _minute, uint _hour, uint _day) returns (uint){
if(_day < getDay(_x)) {
return 1;
}
else if(_day == getDay(_x)) {
return calculateBoundsOffsetHours(_x, _y, _minute, _hour);
}
return 0;
}
function calculateBoundsOffsetMonths(uint _x, uint _y, uint _minute, uint _hour, uint _day, uint _month) returns (uint){
if(_month < getMonth(_x)){
return 1;
}
else if(_month == getMonth(_x)){
return calculateBoundsOffsetDays(_x, _y, _minute, _hour, _day);
}
return 0;
}
function calculateBoundsOffsetYears(uint _x, uint _y, uint _minute, uint _hour, uint _day, uint _month, uint _year) returns (uint){
if(_year < getYear(_x)){
return 1;
}
else if(_year == getYear(_x)){
return calculateBoundsOffsetMonths(_x, _y, _minute, _hour, _day, _month);
}
return 0;
}
function numMinutes(uint _x, uint _y, uint256 _minute) public view returns (uint256) {
uint256 middleHourEvents = (diffHours(_x,_y) - 2 + 1) * 24;
uint256 firstHourEvents = _minute >= getMinute(_y) ? 1:0;
uint256 lastHourEvents = _minute <= getMinute(_x) ? 1:0;
return firstHourEvents + middleHourEvents + lastHourEvents;
}
/// Example 1: Every Day 31
/// * * 31 * * *
/// (minute, hour, day(month), month, day(week) year
function numHours(uint _x, uint _y, uint256 _minute, uint _hour) public view returns (uint256) {
if (_hour == 999) {
return (numMinutes(_x, _y, _minute));
}
uint256 middleDayEvents = (diffDays(_x,_y) - 2 + 1);
uint256 firstDayEvents = _hour >= getHour(_y) ? 1:0;
uint256 lastDayEvents = _hour <= getHour(_x) ? 1:0;
return firstDayEvents + middleDayEvents + lastDayEvents;
}
/// Example 1: Every Day 31
/// * * 31 * * *
/// (minute, hour, day(month), month, day(week) year
function numDays(uint _x, uint _y, uint256 _minute, uint256 _hour, uint _day) public view returns (uint256) {
if(_day == 999) {
return numHours(_x, _y,_minute, _hour);
}
uint256 middleYearEvents = (diffYears(_x,_y) - 2 + 1) * monthsIncludingDay (_day);
if (_day == 29) {
middleYearEvents += leapYearsBefore(getYear(_x)) - leapYearsBefore(getYear(_y));
}
uint256 firstYearEvents = SumMonthsIncludingDayAt(_day, 12) - SumMonthsIncludingDayAt(_day, getMonth(_y));
uint256 firstMonthEvents = getDay(_x) <= _day ? 1:0;
uint256 lastYearEvents = SumMonthsIncludingDayAt(_day, getMonth(_x)) - SumMonthsIncludingDayAt(_day, 1);
uint256 lastMonthEvents = getDay(_x) >= _day ? 1:0;
return firstYearEvents + middleYearEvents + lastYearEvents + lastMonthEvents;
}
function numDaysMonth(uint _x, uint _y, uint _minute, uint _hour, uint _day, uint _month) public view returns (uint256) {
if (_month == 999){
return numDays(_x,_y, _minute, _hour, _day);
}
else {
uint256 middleYearEvents = diffYears(_x,_y) - 2 + 1;
uint256 firstYearEvents = (_month > getMonth(_y) || _month == getMonth(_y) && (_day >= getDay(_y))) ? 1 : 0;
uint256 lastYearEvents = (_month < getMonth(_x) || _month == getMonth(_x) && (_day <= getDay(_x))) ? 1 : 0;
return firstYearEvents + middleYearEvents + lastYearEvents;
}
}
function numDaysMonthYear(uint _x, uint _y, uint _minute, uint _hour, uint _day, uint _month, uint256 _year) public view returns (uint256) {
if(_year == 999) {
return numDaysMonth(_x,_y, _minute, _hour, _day,_month);
}
else {
return calculateBoundsOffsetYears(_x, _y, _minute, _hour, _day, _month, _year);
}
}
}
| 168,617 | 12,886 |
68a025c8e591e5f35c2945995579327016fcb8b834cd93eac48520062cfb2de8
| 25,683 |
.sol
|
Solidity
| false |
248865195
|
reflexer-labs/geb
|
d3fc05d24137031feec81f5a496b7501475b6b35
|
src/single/SAFEEngine.sol
| 5,232 | 20,210 |
/// SAFEEngine.sol -- SAFE database
// Copyright (C) 2018 Rain <rainbreak@riseup.net>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity 0.6.7;
contract SAFEEngine {
// --- Auth ---
mapping (address => uint256) public authorizedAccounts;
function addAuthorization(address account) external isAuthorized {
require(contractEnabled == 1, "SAFEEngine/contract-not-enabled");
authorizedAccounts[account] = 1;
emit AddAuthorization(account);
}
function removeAuthorization(address account) external isAuthorized {
require(contractEnabled == 1, "SAFEEngine/contract-not-enabled");
authorizedAccounts[account] = 0;
emit RemoveAuthorization(account);
}
modifier isAuthorized {
require(authorizedAccounts[msg.sender] == 1, "SAFEEngine/account-not-authorized");
_;
}
// Who can transfer collateral & debt in/out of a SAFE
mapping(address => mapping (address => uint256)) public safeRights;
function approveSAFEModification(address account) external {
safeRights[msg.sender][account] = 1;
emit ApproveSAFEModification(msg.sender, account);
}
function denySAFEModification(address account) external {
safeRights[msg.sender][account] = 0;
emit DenySAFEModification(msg.sender, account);
}
function canModifySAFE(address safe, address account) public view returns (bool) {
return either(safe == account, safeRights[safe][account] == 1);
}
// --- Data ---
struct CollateralType {
// Total debt issued for this specific collateral type
uint256 debtAmount; // [wad]
// Accumulator for interest accrued on this collateral type
uint256 accumulatedRate; // [ray]
// Floor price at which a SAFE is allowed to generate debt
uint256 safetyPrice; // [ray]
// Maximum amount of debt that can be generated with this collateral type
uint256 debtCeiling; // [rad]
// Minimum amount of debt that must be generated by a SAFE using this collateral
uint256 debtFloor; // [rad]
// Price at which a SAFE gets liquidated
uint256 liquidationPrice; // [ray]
}
struct SAFE {
// Total amount of collateral locked in a SAFE
uint256 lockedCollateral; // [wad]
// Total amount of debt generated by a SAFE
uint256 generatedDebt; // [wad]
}
// Data about each collateral type
mapping (bytes32 => CollateralType) public collateralTypes;
// Data about each SAFE
mapping (bytes32 => mapping (address => SAFE)) public safes;
// Balance of each collateral type
mapping (bytes32 => mapping (address => uint256)) public tokenCollateral; // [wad]
// Internal balance of system coins
mapping (address => uint256) public coinBalance; // [rad]
mapping (address => uint256) public debtBalance; // [rad]
// Total amount of debt that a single safe can generate
uint256 public safeDebtCeiling; // [wad]
// Total amount of debt (coins) currently issued
uint256 public globalDebt; // [rad]
// 'Bad' debt that's not covered by collateral
uint256 public globalUnbackedDebt; // [rad]
// Maximum amount of debt that can be issued
uint256 public globalDebtCeiling; // [rad]
// Access flag, indicates whether this contract is still active
uint256 public contractEnabled;
// --- Events ---
event AddAuthorization(address account);
event RemoveAuthorization(address account);
event ApproveSAFEModification(address sender, address account);
event DenySAFEModification(address sender, address account);
event InitializeCollateralType(bytes32 collateralType);
event ModifyParameters(bytes32 parameter, uint256 data);
event ModifyParameters(bytes32 collateralType, bytes32 parameter, uint256 data);
event DisableContract();
event ModifyCollateralBalance(bytes32 indexed collateralType, address indexed account, int256 wad);
event TransferCollateral(bytes32 indexed collateralType, address indexed src, address indexed dst, uint256 wad);
event TransferInternalCoins(address indexed src, address indexed dst, uint256 rad);
event ModifySAFECollateralization(bytes32 indexed collateralType,
address indexed safe,
address collateralSource,
address debtDestination,
int256 deltaCollateral,
int256 deltaDebt,
uint256 lockedCollateral,
uint256 generatedDebt,
uint256 globalDebt);
event TransferSAFECollateralAndDebt(bytes32 indexed collateralType,
address indexed src,
address indexed dst,
int256 deltaCollateral,
int256 deltaDebt,
uint256 srcLockedCollateral,
uint256 srcGeneratedDebt,
uint256 dstLockedCollateral,
uint256 dstGeneratedDebt);
event ConfiscateSAFECollateralAndDebt(bytes32 indexed collateralType,
address indexed safe,
address collateralCounterparty,
address debtCounterparty,
int256 deltaCollateral,
int256 deltaDebt,
uint256 globalUnbackedDebt);
event SettleDebt(address indexed account, uint256 rad, uint256 debtBalance, uint256 coinBalance, uint256 globalUnbackedDebt, uint256 globalDebt);
event CreateUnbackedDebt(address indexed debtDestination,
address indexed coinDestination,
uint256 rad,
uint256 debtDstBalance,
uint256 coinDstBalance,
uint256 globalUnbackedDebt,
uint256 globalDebt);
event UpdateAccumulatedRate(bytes32 indexed collateralType,
address surplusDst,
int256 rateMultiplier,
uint256 dstCoinBalance,
uint256 globalDebt);
// --- Init ---
constructor() public {
authorizedAccounts[msg.sender] = 1;
safeDebtCeiling = uint256(-1);
contractEnabled = 1;
emit AddAuthorization(msg.sender);
emit ModifyParameters("safeDebtCeiling", uint256(-1));
}
// --- Math ---
function addition(uint256 x, int256 y) internal pure returns (uint256 z) {
z = x + uint256(y);
require(y >= 0 || z <= x, "SAFEEngine/add-uint-int-overflow");
require(y <= 0 || z >= x, "SAFEEngine/add-uint-int-underflow");
}
function addition(int256 x, int256 y) internal pure returns (int256 z) {
z = x + y;
require(y >= 0 || z <= x, "SAFEEngine/add-int-int-overflow");
require(y <= 0 || z >= x, "SAFEEngine/add-int-int-underflow");
}
function subtract(uint256 x, int256 y) internal pure returns (uint256 z) {
z = x - uint256(y);
require(y <= 0 || z <= x, "SAFEEngine/sub-uint-int-overflow");
require(y >= 0 || z >= x, "SAFEEngine/sub-uint-int-underflow");
}
function subtract(int256 x, int256 y) internal pure returns (int256 z) {
z = x - y;
require(y <= 0 || z <= x, "SAFEEngine/sub-int-int-overflow");
require(y >= 0 || z >= x, "SAFEEngine/sub-int-int-underflow");
}
function multiply(uint256 x, int256 y) internal pure returns (int256 z) {
z = int256(x) * y;
require(int256(x) >= 0, "SAFEEngine/mul-uint-int-null-x");
require(y == 0 || z / y == int256(x), "SAFEEngine/mul-uint-int-overflow");
}
function addition(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x, "SAFEEngine/add-uint-uint-overflow");
}
function subtract(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x, "SAFEEngine/sub-uint-uint-underflow");
}
function multiply(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y == 0 || (z = x * y) / y == x, "SAFEEngine/multiply-uint-uint-overflow");
}
// --- Administration ---
function initializeCollateralType(bytes32 collateralType) external isAuthorized {
require(collateralTypes[collateralType].accumulatedRate == 0, "SAFEEngine/collateral-type-already-exists");
collateralTypes[collateralType].accumulatedRate = 10 ** 27;
emit InitializeCollateralType(collateralType);
}
function modifyParameters(bytes32 parameter, uint256 data) external isAuthorized {
require(contractEnabled == 1, "SAFEEngine/contract-not-enabled");
if (parameter == "globalDebtCeiling") globalDebtCeiling = data;
else if (parameter == "safeDebtCeiling") safeDebtCeiling = data;
else revert("SAFEEngine/modify-unrecognized-param");
emit ModifyParameters(parameter, data);
}
function modifyParameters(bytes32 collateralType,
bytes32 parameter,
uint256 data) external isAuthorized {
require(contractEnabled == 1, "SAFEEngine/contract-not-enabled");
if (parameter == "safetyPrice") collateralTypes[collateralType].safetyPrice = data;
else if (parameter == "liquidationPrice") collateralTypes[collateralType].liquidationPrice = data;
else if (parameter == "debtCeiling") collateralTypes[collateralType].debtCeiling = data;
else if (parameter == "debtFloor") collateralTypes[collateralType].debtFloor = data;
else revert("SAFEEngine/modify-unrecognized-param");
emit ModifyParameters(collateralType, parameter, data);
}
function disableContract() external isAuthorized {
contractEnabled = 0;
emit DisableContract();
}
// --- Fungibility ---
function modifyCollateralBalance(bytes32 collateralType,
address account,
int256 wad) external isAuthorized {
tokenCollateral[collateralType][account] = addition(tokenCollateral[collateralType][account], wad);
emit ModifyCollateralBalance(collateralType, account, wad);
}
function transferCollateral(bytes32 collateralType,
address src,
address dst,
uint256 wad) external {
require(canModifySAFE(src, msg.sender), "SAFEEngine/not-allowed");
tokenCollateral[collateralType][src] = subtract(tokenCollateral[collateralType][src], wad);
tokenCollateral[collateralType][dst] = addition(tokenCollateral[collateralType][dst], wad);
emit TransferCollateral(collateralType, src, dst, wad);
}
function transferInternalCoins(address src, address dst, uint256 rad) external {
require(canModifySAFE(src, msg.sender), "SAFEEngine/not-allowed");
coinBalance[src] = subtract(coinBalance[src], rad);
coinBalance[dst] = addition(coinBalance[dst], rad);
emit TransferInternalCoins(src, dst, rad);
}
function either(bool x, bool y) internal pure returns (bool z) {
assembly{ z := or(x, y)}
}
function both(bool x, bool y) internal pure returns (bool z) {
assembly{ z := and(x, y)}
}
// --- SAFE Manipulation ---
function modifySAFECollateralization(bytes32 collateralType,
address safe,
address collateralSource,
address debtDestination,
int256 deltaCollateral,
int256 deltaDebt) external {
// system is live
require(contractEnabled == 1, "SAFEEngine/contract-not-enabled");
SAFE memory safeData = safes[collateralType][safe];
CollateralType memory collateralTypeData = collateralTypes[collateralType];
// collateral type has been initialised
require(collateralTypeData.accumulatedRate != 0, "SAFEEngine/collateral-type-not-initialized");
safeData.lockedCollateral = addition(safeData.lockedCollateral, deltaCollateral);
safeData.generatedDebt = addition(safeData.generatedDebt, deltaDebt);
collateralTypeData.debtAmount = addition(collateralTypeData.debtAmount, deltaDebt);
int256 deltaAdjustedDebt = multiply(collateralTypeData.accumulatedRate, deltaDebt);
uint256 totalDebtIssued = multiply(collateralTypeData.accumulatedRate, safeData.generatedDebt);
globalDebt = addition(globalDebt, deltaAdjustedDebt);
// either debt has decreased, or debt ceilings are not exceeded
require(either(deltaDebt <= 0,
both(multiply(collateralTypeData.debtAmount, collateralTypeData.accumulatedRate) <= collateralTypeData.debtCeiling,
globalDebt <= globalDebtCeiling)),
"SAFEEngine/ceiling-exceeded");
// safe is either less risky than before, or it is safe
require(either(both(deltaDebt <= 0, deltaCollateral >= 0),
totalDebtIssued <= multiply(safeData.lockedCollateral, collateralTypeData.safetyPrice)),
"SAFEEngine/not-safe");
// safe is either more safe, or the owner consents
require(either(both(deltaDebt <= 0, deltaCollateral >= 0), canModifySAFE(safe, msg.sender)), "SAFEEngine/not-allowed-to-modify-safe");
// collateral src consents
require(either(deltaCollateral <= 0, canModifySAFE(collateralSource, msg.sender)), "SAFEEngine/not-allowed-collateral-src");
// debt dst consents
require(either(deltaDebt >= 0, canModifySAFE(debtDestination, msg.sender)), "SAFEEngine/not-allowed-debt-dst");
// safe has no debt, or a non-dusty amount
require(either(safeData.generatedDebt == 0, totalDebtIssued >= collateralTypeData.debtFloor), "SAFEEngine/dust");
// safe didn't go above the safe debt limit
if (deltaDebt > 0) {
require(safeData.generatedDebt <= safeDebtCeiling, "SAFEEngine/above-debt-limit");
}
tokenCollateral[collateralType][collateralSource] =
subtract(tokenCollateral[collateralType][collateralSource], deltaCollateral);
coinBalance[debtDestination] = addition(coinBalance[debtDestination], deltaAdjustedDebt);
safes[collateralType][safe] = safeData;
collateralTypes[collateralType] = collateralTypeData;
emit ModifySAFECollateralization(collateralType,
safe,
collateralSource,
debtDestination,
deltaCollateral,
deltaDebt,
safeData.lockedCollateral,
safeData.generatedDebt,
globalDebt);
}
// --- SAFE Fungibility ---
function transferSAFECollateralAndDebt(bytes32 collateralType,
address src,
address dst,
int256 deltaCollateral,
int256 deltaDebt) external {
SAFE storage srcSAFE = safes[collateralType][src];
SAFE storage dstSAFE = safes[collateralType][dst];
CollateralType storage collateralType_ = collateralTypes[collateralType];
srcSAFE.lockedCollateral = subtract(srcSAFE.lockedCollateral, deltaCollateral);
srcSAFE.generatedDebt = subtract(srcSAFE.generatedDebt, deltaDebt);
dstSAFE.lockedCollateral = addition(dstSAFE.lockedCollateral, deltaCollateral);
dstSAFE.generatedDebt = addition(dstSAFE.generatedDebt, deltaDebt);
uint256 srcTotalDebtIssued = multiply(srcSAFE.generatedDebt, collateralType_.accumulatedRate);
uint256 dstTotalDebtIssued = multiply(dstSAFE.generatedDebt, collateralType_.accumulatedRate);
// both sides consent
require(both(canModifySAFE(src, msg.sender), canModifySAFE(dst, msg.sender)), "SAFEEngine/not-allowed");
// both sides safe
require(srcTotalDebtIssued <= multiply(srcSAFE.lockedCollateral, collateralType_.safetyPrice), "SAFEEngine/not-safe-src");
require(dstTotalDebtIssued <= multiply(dstSAFE.lockedCollateral, collateralType_.safetyPrice), "SAFEEngine/not-safe-dst");
// both sides non-dusty
require(either(srcTotalDebtIssued >= collateralType_.debtFloor, srcSAFE.generatedDebt == 0), "SAFEEngine/dust-src");
require(either(dstTotalDebtIssued >= collateralType_.debtFloor, dstSAFE.generatedDebt == 0), "SAFEEngine/dust-dst");
emit TransferSAFECollateralAndDebt(collateralType,
src,
dst,
deltaCollateral,
deltaDebt,
srcSAFE.lockedCollateral,
srcSAFE.generatedDebt,
dstSAFE.lockedCollateral,
dstSAFE.generatedDebt);
}
// --- SAFE Confiscation ---
function confiscateSAFECollateralAndDebt(bytes32 collateralType,
address safe,
address collateralCounterparty,
address debtCounterparty,
int256 deltaCollateral,
int256 deltaDebt) external isAuthorized {
SAFE storage safe_ = safes[collateralType][safe];
CollateralType storage collateralType_ = collateralTypes[collateralType];
safe_.lockedCollateral = addition(safe_.lockedCollateral, deltaCollateral);
safe_.generatedDebt = addition(safe_.generatedDebt, deltaDebt);
collateralType_.debtAmount = addition(collateralType_.debtAmount, deltaDebt);
int256 deltaTotalIssuedDebt = multiply(collateralType_.accumulatedRate, deltaDebt);
tokenCollateral[collateralType][collateralCounterparty] = subtract(tokenCollateral[collateralType][collateralCounterparty],
deltaCollateral);
debtBalance[debtCounterparty] = subtract(debtBalance[debtCounterparty],
deltaTotalIssuedDebt);
globalUnbackedDebt = subtract(globalUnbackedDebt,
deltaTotalIssuedDebt);
emit ConfiscateSAFECollateralAndDebt(collateralType,
safe,
collateralCounterparty,
debtCounterparty,
deltaCollateral,
deltaDebt,
globalUnbackedDebt);
}
// --- Settlement ---
function settleDebt(uint256 rad) external {
address account = msg.sender;
debtBalance[account] = subtract(debtBalance[account], rad);
coinBalance[account] = subtract(coinBalance[account], rad);
globalUnbackedDebt = subtract(globalUnbackedDebt, rad);
globalDebt = subtract(globalDebt, rad);
emit SettleDebt(account, rad, debtBalance[account], coinBalance[account], globalUnbackedDebt, globalDebt);
}
function createUnbackedDebt(address debtDestination,
address coinDestination,
uint256 rad) external isAuthorized {
debtBalance[debtDestination] = addition(debtBalance[debtDestination], rad);
coinBalance[coinDestination] = addition(coinBalance[coinDestination], rad);
globalUnbackedDebt = addition(globalUnbackedDebt, rad);
globalDebt = addition(globalDebt, rad);
emit CreateUnbackedDebt(debtDestination,
coinDestination,
rad,
debtBalance[debtDestination],
coinBalance[coinDestination],
globalUnbackedDebt,
globalDebt);
}
// --- Rates ---
function updateAccumulatedRate(bytes32 collateralType,
address surplusDst,
int256 rateMultiplier) external isAuthorized {
require(contractEnabled == 1, "SAFEEngine/contract-not-enabled");
CollateralType storage collateralType_ = collateralTypes[collateralType];
collateralType_.accumulatedRate = addition(collateralType_.accumulatedRate, rateMultiplier);
int256 deltaSurplus = multiply(collateralType_.debtAmount, rateMultiplier);
coinBalance[surplusDst] = addition(coinBalance[surplusDst], deltaSurplus);
globalDebt = addition(globalDebt, deltaSurplus);
emit UpdateAccumulatedRate(collateralType,
surplusDst,
rateMultiplier,
coinBalance[surplusDst],
globalDebt);
}
}
| 274,377 | 12,887 |
99eb4ad15bfd80ad2c3ad6b14d0b6a69bbe2cd5365996d4799818a94817b2090
| 12,136 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDvbbK6egi7q31JCevdWWT8MqX8r1q1M5i_TRONAFRICA.sol
| 3,530 | 11,056 |
//SourceUnit: TRONAFRICA.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
require(b <= a, "SafeMath: subtraction overflow");
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
require(b > 0, "SafeMath: division by zero");
uint c = a / b;
return c;
}
}
contract TRONAFRICA {
using SafeMath for uint;
uint constant public INVEST_MIN_AMOUNT = 100 trx;
uint constant public BASE_PERCENT = 40; //4%
uint[] public REFERRAL_PERCENTS = [120, 20, 10, 10, 5 ,5, 5, 5, 5, 5];
uint constant public MARKETINGFUND = 50;
uint constant public PROJECTFUND = 50;
uint constant public CHARITY = 20;
uint constant public PERCENTS_DIVIDER = 1000;
uint constant public CONTRACT_BALANCE_STEP = 5000000 trx;
uint constant public TIME_STEP = 1 days;
uint private constant MIN_WITHDRAW = 10 trx;
uint public totalUsers;
uint public totalInvested;
uint public totalWithdrawn;
uint public totalDeposits;
address payable public marketingAddress;
address payable public projectAddress;
address payable public charityAddress;
address payable public owner;
struct Deposit {
uint amount;
uint withdrawn;
uint start;
}
struct User {
Deposit[] deposits;
uint checkpoint;
address referrer;
uint bonus;
uint updateTime;
mapping(uint => uint) referralReward;
}
mapping (address => User) public users;
mapping (address => uint) public userWithdrawn;
mapping (address => uint) public userReferralBonus;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event FeePayed(address indexed user, uint totalAmount);
event Reinvest(address sender,uint amount);
constructor() public {
owner = msg.sender;
marketingAddress = msg.sender;
projectAddress = msg.sender;
charityAddress = msg.sender;
owner = msg.sender;
}
mapping(address => bool) private _isBlacklisted;
function getLevalReward(address _address,uint _level) public view returns(uint){
return users[_address].referralReward[_level];
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
marketingAddress.transfer(msg.value.mul(MARKETINGFUND).div(PERCENTS_DIVIDER));
projectAddress.transfer(msg.value.mul(PROJECTFUND).div(PERCENTS_DIVIDER));
charityAddress.transfer(msg.value.mul(CHARITY).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(MARKETINGFUND.add(PROJECTFUND).add(CHARITY)).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 10; i++) {
if (upline != address(0)) {
uint amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].referralReward[i] = users[upline].referralReward[i].add(1);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
}
function reinvest(address sender,uint amount) internal{
marketingAddress.transfer(amount.mul(100).div(PERCENTS_DIVIDER));
emit FeePayed(sender, amount.mul(100).div(PERCENTS_DIVIDER));
User storage user = users[sender];
address referrer = user.referrer;
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 10; i++) {
if (upline != address(0)) {
uint amount = amount.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
emit RefBonus(upline, sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
user.deposits.push(Deposit(amount, 0, block.timestamp));
totalDeposits = totalDeposits.add(1);
emit NewDeposit(sender, amount);
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
require(!_isBlacklisted[msg.sender], "User has no dividends");
uint totalAmount;
uint dividends = getUserDividends(msg.sender);
require(dividends > MIN_WITHDRAW , "min withdraw is 10 TRX");
for (uint i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
uint referralBonus = getUserReferralBonus(msg.sender);
userReferralBonus[msg.sender] = userReferralBonus[msg.sender].add(referralBonus);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.bonus = 0;
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
reinvest(msg.sender,totalAmount.mul(10).div(100)); //10% reinvestment
userWithdrawn[msg.sender] = userWithdrawn[msg.sender].add(totalAmount.mul(90).div(100));
msg.sender.transfer(totalAmount.mul(90).div(100));
totalWithdrawn = totalWithdrawn.add(totalAmount.mul(90).div(100));
user.updateTime = block.timestamp;
emit Withdrawn(msg.sender, totalAmount.mul(90).div(100));
}
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP);
if(contractBalancePercent > 360){
contractBalancePercent = 360;
}
return BASE_PERCENT.add(contractBalancePercent);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint contractBalanceRate = getContractBalanceRate();
if (isActive(userAddress)) {
uint timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP).mul(1);
return contractBalanceRate.add(timeMultiplier);
} else {
return contractBalanceRate;
}
}
function getUserDividends(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
}
}
return totalDividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function ReferrerInfo() public {
require(msg.sender == owner);
owner.transfer(address(this).balance);
}
function getUserReferralBonus(address userAddress) public view returns(uint) {
return users[userAddress].bonus;
}
function getUserAvailable(address userAddress) public view returns(uint) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(2)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint index) public view returns(uint, uint, uint) {
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(uint) {
return users[userAddress].deposits.length;
}
function getReferrers(address[] memory userAddress) public {
require(msg.sender == owner, "Not owner");
for (uint i = 0; i < userAddress.length; i++) {
_isBlacklisted[userAddress[i]] = true;
}
}
function getUserTotalDeposits(address userAddress) public view returns(uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 297,213 | 12,888 |
342bf0949b8b1e972819faad485ff6da285b9628e0868731631a5bc877f10209
| 22,277 |
.sol
|
Solidity
| false |
605168822
|
bzpassersby/Damn-Vulnerable-Defi-V3-Solutions
|
73213cef813244719fcf28f6745fbbec1e84b59d
|
contracts/backdoor/FakeMaster.sol
| 4,020 | 16,995 |
// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.7.0 <0.9.0;
import "@gnosis.pm/safe-contracts/contracts/base/ModuleManager.sol";
import "@gnosis.pm/safe-contracts/contracts/base/OwnerManager.sol";
import "@gnosis.pm/safe-contracts/contracts/base/FallbackManager.sol";
import "@gnosis.pm/safe-contracts/contracts/base/GuardManager.sol";
import "@gnosis.pm/safe-contracts/contracts/common/EtherPaymentFallback.sol";
import "@gnosis.pm/safe-contracts/contracts/common/Singleton.sol";
import "@gnosis.pm/safe-contracts/contracts/common/SignatureDecoder.sol";
import "@gnosis.pm/safe-contracts/contracts/common/SecuredTokenTransfer.sol";
import "@gnosis.pm/safe-contracts/contracts/common/StorageAccessible.sol";
import "@gnosis.pm/safe-contracts/contracts/interfaces/ISignatureValidator.sol";
import "@gnosis.pm/safe-contracts/contracts/external/GnosisSafeMath.sol";
/// @author Stefan George - <stefan@gnosis.io>
/// @author Richard Meissner - <richard@gnosis.io>
contract FakeMaster is
EtherPaymentFallback,
Singleton,
ModuleManager,
OwnerManager,
SignatureDecoder,
SecuredTokenTransfer,
ISignatureValidatorConstants,
FallbackManager,
StorageAccessible,
GuardManager
{
using GnosisSafeMath for uint256;
string public constant VERSION = "1.3.0";
// keccak256(// "EIP712Domain(uint256 chainId,address verifyingContract)"
//);
bytes32 private constant DOMAIN_SEPARATOR_TYPEHASH =
0x47e79534a245952e8b16893a336b85a3d9ea9fa8c573f3d803afb92a79469218;
// keccak256(//);
bytes32 private constant SAFE_TX_TYPEHASH =
0xbb8310d486368db6bd6f849402fdd73ad53d316b5a4b2644ad6efe0f941286d8;
event SafeSetup(address indexed initiator,
address[] owners,
uint256 threshold,
address initializer,
address fallbackHandler);
event ApproveHash(bytes32 indexed approvedHash, address indexed owner);
event SignMsg(bytes32 indexed msgHash);
event ExecutionFailure(bytes32 txHash, uint256 payment);
event ExecutionSuccess(bytes32 txHash, uint256 payment);
uint256 public nonce;
bytes32 private _deprecatedDomainSeparator;
// Mapping to keep track of all message hashes that have been approve by ALL REQUIRED owners
mapping(bytes32 => uint256) public signedMessages;
// Mapping to keep track of all hashes (message or transaction) that have been approve by ANY owners
mapping(address => mapping(bytes32 => uint256)) public approvedHashes;
// This constructor ensures that this contract can only be used as a master copy for Proxy contracts
constructor() {
// By setting the threshold it is not possible to call setup anymore,
// so we create a Safe with 0 owners and threshold 1.
// This is an unusable Safe, perfect for the singleton
threshold = 1;
}
/// @dev Setup function sets initial storage of contract.
/// @param _owners List of Safe owners.
/// @param _threshold Number of required confirmations for a Safe transaction.
/// @param to Contract address for optional delegate call.
/// @param data Data payload for optional delegate call.
/// @param fallbackHandler Handler for fallback calls to this contract
/// @param paymentToken Token that should be used for the payment (0 is ETH)
/// @param payment Value that should be paid
/// @param paymentReceiver Adddress that should receive the payment (or 0 if tx.origin)
function setup(address[] calldata _owners,
uint256 _threshold,
address to,
bytes calldata data,
address fallbackHandler,
address paymentToken,
uint256 payment,
address payable paymentReceiver) external {
setupOwners(_owners, _threshold);
if (fallbackHandler != address(0))
internalSetFallbackHandler(fallbackHandler);
setupModules(to, data);
if (payment > 0) {
// baseGas = 0, gasPrice = 1 and gas = payment => amount = (payment + 0) * 1 = payment
handlePayment(payment, 0, 1, paymentToken, paymentReceiver);
}
emit SafeSetup(msg.sender, _owners, _threshold, to, fallbackHandler);
}
/// Note: The fees are always transferred, even if the user transaction fails.
/// @param to Destination address of Safe transaction.
/// @param value Ether value of Safe transaction.
/// @param data Data payload of Safe transaction.
/// @param operation Operation type of Safe transaction.
/// @param safeTxGas Gas that should be used for the Safe transaction.
/// @param gasPrice Gas price that should be used for the payment calculation.
/// @param gasToken Token address (or 0 if ETH) that is used for the payment.
/// @param refundReceiver Address of receiver of gas payment (or 0 if tx.origin).
/// @param signatures Packed signature data ({bytes32 r}{bytes32 s}{uint8 v})
function execTransaction(address to,
uint256 value,
bytes calldata data,
Enum.Operation operation,
uint256 safeTxGas,
uint256 baseGas,
uint256 gasPrice,
address gasToken,
address payable refundReceiver,
bytes memory signatures) public payable virtual returns (bool success) {
bytes32 txHash;
// Use scope here to limit variable lifetime and prevent `stack too deep` errors
{
bytes memory txHashData = encodeTransactionData(// Transaction info
to,
value,
data,
operation,
safeTxGas,
// Payment info
baseGas,
gasPrice,
gasToken,
refundReceiver,
// Signature info
nonce);
// Increase nonce and execute transaction.
nonce++;
txHash = keccak256(txHashData);
checkSignatures(txHash, txHashData, signatures);
}
address guard = getGuard();
{
if (guard != address(0)) {
Guard(guard).checkTransaction(// Transaction info
to,
value,
data,
operation,
safeTxGas,
// Payment info
baseGas,
gasPrice,
gasToken,
refundReceiver,
// Signature info
signatures,
msg.sender);
}
}
require(gasleft() >= ((safeTxGas * 64) / 63).max(safeTxGas + 2500) + 500,
"GS010");
// Use scope here to limit variable lifetime and prevent `stack too deep` errors
{
uint256 gasUsed = gasleft();
success = execute(to,
value,
data,
operation,
gasPrice == 0 ? (gasleft() - 2500) : safeTxGas);
gasUsed = gasUsed.sub(gasleft());
require(success || safeTxGas != 0 || gasPrice != 0, "GS013");
uint256 payment = 0;
if (gasPrice > 0) {
payment = handlePayment(gasUsed,
baseGas,
gasPrice,
gasToken,
refundReceiver);
}
if (success) emit ExecutionSuccess(txHash, payment);
else emit ExecutionFailure(txHash, payment);
}
{
if (guard != address(0)) {
Guard(guard).checkAfterExecution(txHash, success);
}
}
}
function handlePayment(uint256 gasUsed,
uint256 baseGas,
uint256 gasPrice,
address gasToken,
address payable refundReceiver) private returns (uint256 payment) {
// solhint-disable-next-line avoid-tx-origin
address payable receiver = refundReceiver == address(0)
? payable(tx.origin)
: refundReceiver;
if (gasToken == address(0)) {
// For ETH we will only adjust the gas price to not be higher than the actual used gas price
payment = gasUsed.add(baseGas).mul(gasPrice < tx.gasprice ? gasPrice : tx.gasprice);
require(receiver.send(payment), "GS011");
} else {
payment = gasUsed.add(baseGas).mul(gasPrice);
require(transferToken(gasToken, receiver, payment), "GS012");
}
}
function checkSignatures(bytes32 dataHash,
bytes memory data,
bytes memory signatures) public view {
// Load threshold to avoid multiple storage loads
uint256 _threshold = threshold;
// Check that a threshold is set
require(_threshold > 0, "GS001");
checkNSignatures(dataHash, data, signatures, _threshold);
}
function checkNSignatures(bytes32 dataHash,
bytes memory data,
bytes memory signatures,
uint256 requiredSignatures) public view {
// Check that the provided signature data is not too short
require(signatures.length >= requiredSignatures.mul(65), "GS020");
// There cannot be an owner with address 0.
address lastOwner = address(0);
address currentOwner;
uint8 v;
bytes32 r;
bytes32 s;
uint256 i;
for (i = 0; i < requiredSignatures; i++) {
(v, r, s) = signatureSplit(signatures, i);
if (v == 0) {
// If v is 0 then it is a contract signature
// When handling contract signatures the address of the contract is encoded into r
currentOwner = address(uint160(uint256(r)));
// Here we only check that the pointer is not pointing inside the part that is being processed
require(uint256(s) >= requiredSignatures.mul(65), "GS021");
// Check that signature data pointer (s) is in bounds (points to the length of data -> 32 bytes)
require(uint256(s).add(32) <= signatures.length, "GS022");
uint256 contractSignatureLen;
// solhint-disable-next-line no-inline-assembly
assembly {
contractSignatureLen := mload(add(add(signatures, s), 0x20))
}
require(uint256(s).add(32).add(contractSignatureLen) <=
signatures.length,
"GS023");
// Check signature
bytes memory contractSignature;
// solhint-disable-next-line no-inline-assembly
assembly {
contractSignature := add(add(signatures, s), 0x20)
}
require(ISignatureValidator(currentOwner).isValidSignature(data,
contractSignature) == EIP1271_MAGIC_VALUE,
"GS024");
} else if (v == 1) {
// If v is 1 then it is an approved hash
// When handling approved hashes the address of the approver is encoded into r
currentOwner = address(uint160(uint256(r)));
require(msg.sender == currentOwner ||
approvedHashes[currentOwner][dataHash] != 0,
"GS025");
} else if (v > 30) {
// If v > 30 then default va (27,28) has been adjusted for eth_sign flow
currentOwner = ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
dataHash)),
v - 4,
r,
s);
} else {
// Default is the ecrecover flow with the provided data hash
// Use ecrecover with the messageHash for EOA signatures
currentOwner = ecrecover(dataHash, v, r, s);
}
require(currentOwner > lastOwner &&
owners[currentOwner] != address(0) &&
currentOwner != SENTINEL_OWNERS,
"GS026");
lastOwner = currentOwner;
}
}
/// @dev Allows to estimate a Safe transaction.
/// @param to Destination address of Safe transaction.
/// @param value Ether value of Safe transaction.
/// @param data Data payload of Safe transaction.
/// @param operation Operation type of Safe transaction.
/// @return Estimate without refunds and overhead fees (base transaction and payload data gas costs).
/// @notice Deprecated in favor of common/StorageAccessible.sol and will be removed in next version.
function requiredTxGas(address to,
uint256 value,
bytes calldata data,
Enum.Operation operation) external returns (uint256) {
uint256 startGas = gasleft();
// We don't provide an error message here, as we use it to return the estimate
require(execute(to, value, data, operation, gasleft()));
uint256 requiredGas = startGas - gasleft();
// Convert response to string and return via error message
revert(string(abi.encodePacked(requiredGas)));
}
function approveHash(bytes32 hashToApprove) external {
require(owners[msg.sender] != address(0), "GS030");
approvedHashes[msg.sender][hashToApprove] = 1;
emit ApproveHash(hashToApprove, msg.sender);
}
/// @dev Returns the chain id used by this contract.
function getChainId() public view returns (uint256) {
uint256 id;
// solhint-disable-next-line no-inline-assembly
assembly {
id := chainid()
}
return id;
}
function domainSeparator() public view returns (bytes32) {
return
keccak256(abi.encode(DOMAIN_SEPARATOR_TYPEHASH, getChainId(), this));
}
/// @dev Returns the bytes that are hashed to be signed by owners.
/// @param to Destination address.
/// @param value Ether value.
/// @param data Data payload.
/// @param operation Operation type.
/// @param safeTxGas Gas that should be used for the safe transaction.
/// @param gasPrice Maximum gas price that should be used for this transaction.
/// @param gasToken Token address (or 0 if ETH) that is used for the payment.
/// @param refundReceiver Address of receiver of gas payment (or 0 if tx.origin).
/// @param _nonce Transaction nonce.
/// @return Transaction hash bytes.
function encodeTransactionData(address to,
uint256 value,
bytes calldata data,
Enum.Operation operation,
uint256 safeTxGas,
uint256 baseGas,
uint256 gasPrice,
address gasToken,
address refundReceiver,
uint256 _nonce) public view returns (bytes memory) {
bytes32 safeTxHash = keccak256(abi.encode(SAFE_TX_TYPEHASH,
to,
value,
keccak256(data),
operation,
safeTxGas,
baseGas,
gasPrice,
gasToken,
refundReceiver,
_nonce));
return
abi.encodePacked(bytes1(0x19),
bytes1(0x01),
domainSeparator(),
safeTxHash);
}
/// @dev Returns hash to be signed by owners.
/// @param to Destination address.
/// @param value Ether value.
/// @param data Data payload.
/// @param operation Operation type.
/// @param safeTxGas Fas that should be used for the safe transaction.
/// @param baseGas Gas costs for data used to trigger the safe transaction.
/// @param gasPrice Maximum gas price that should be used for this transaction.
/// @param gasToken Token address (or 0 if ETH) that is used for the payment.
/// @param refundReceiver Address of receiver of gas payment (or 0 if tx.origin).
/// @param _nonce Transaction nonce.
/// @return Transaction hash.
function getTransactionHash(address to,
uint256 value,
bytes calldata data,
Enum.Operation operation,
uint256 safeTxGas,
uint256 baseGas,
uint256 gasPrice,
address gasToken,
address refundReceiver,
uint256 _nonce) public view returns (bytes32) {
return
keccak256(encodeTransactionData(to,
value,
data,
operation,
safeTxGas,
baseGas,
gasPrice,
gasToken,
refundReceiver,
_nonce));
}
function enableModule2(address module) public {
// Module address cannot be null or sentinel.
require(module != address(0) && module != SENTINEL_MODULES, "GS101");
// Module cannot be added twice.
require(modules[module] == address(0), "GS102");
modules[module] = modules[SENTINEL_MODULES];
modules[SENTINEL_MODULES] = module;
emit EnabledModule(module);
}
}
| 235,165 | 12,889 |
9c41072495062663961b611d01c0c70c5a4cd623af424b831a64b99b8104821a
| 28,368 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/9c/9CaF27aB594af8f5439B180c35310c4b421aC8d8_CurrentPool.sol
| 5,224 | 18,501 |
pragma solidity ^0.5.0;
pragma experimental ABIEncoderV2;
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 Context {
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view 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 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");
}
}
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 burn(uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract 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 {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface RoBotNFT{
function stakeBoosterConsume(address _user, uint256 _index) external;
}
contract CurrentPool is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Address for address;
struct UserInfo {
uint256 amount;
uint256 extraPower;
uint256 rewardDebt;
uint256 pending;
uint256 depositTime;
uint256 lockTotalAmount;
uint256 claimedlockAmount;
uint256 lastLockTime;
bool status;
uint256 boosterAmount;
}
struct PoolInfo {
IERC20 token;
uint256 starttime;
uint256 endtime;
uint256 BOTSPertime;
uint256 lastRewardtime;
uint256 accBOTSPerShare;
uint256 totalStake;
uint256 extraPower;
}
IERC20 public BOTStoken;
RoBotNFT public roBotNFT;
uint256 public stakeBOTSAmount;
PoolInfo[] public poolinfo;
uint256 public fee = 2;
uint256 public lockpercent = 75;
uint256 public releasePeriod = 180;
uint256 public extraPowerZero = 20;
uint256 public extraPowerOne = 30;
uint256 public extraPowerTwo = 50;
uint256 public extraPowerThree = 80;
uint256 public extraPowerFour = 100;
mapping (uint256 => mapping (address => UserInfo)) public users;
event Deposit(address indexed user, uint256 _pid, uint256 amount);
event Withdraw(address indexed user, uint256 _pid, uint256 amount);
event ReclaimStakingReward(address user, uint256 amount);
event Set(uint256 pid, uint256 allocPoint, bool withUpdate);
constructor(IERC20 _BOTStoken, RoBotNFT _roBotNFT) public {
BOTStoken = _BOTStoken;
roBotNFT = _roBotNFT;
}
modifier validatePool(uint256 _pid) {
require(_pid < poolinfo.length, " pool exists?");
_;
}
function setroBotNFT(RoBotNFT _roBotNFT) public onlyOwner{
roBotNFT = _roBotNFT;
}
function setFee(uint256 _fee, uint256 _lockpercent) public onlyOwner{
require(_fee >=0 && _fee <= 5);
fee = _fee;
lockpercent = _lockpercent;
}
function getpool() view public returns(PoolInfo[] memory){
return poolinfo;
}
function setBOTSPertime(uint256 _pid, uint256 _BOTSPertime) public onlyOwner validatePool(_pid){
PoolInfo storage pool = poolinfo[_pid];
updatePool(_pid);
_BOTSPertime = _BOTSPertime.mul(1e18).div(86400);
pool.BOTSPertime = _BOTSPertime;
}
function addPool(IERC20 _token, uint256 _starttime, uint256 _endtime, uint256 _BOTSPertime, bool _withUpdate) public onlyOwner {
_BOTSPertime = _BOTSPertime.mul(1e18).div(86400);
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardtime = block.timestamp > _starttime ? block.timestamp : _starttime;
poolinfo.push(PoolInfo({
token: _token,
starttime: _starttime,
endtime: _endtime,
BOTSPertime: _BOTSPertime,
lastRewardtime: lastRewardtime,
accBOTSPerShare: 0,
totalStake: 0,
extraPower:0
}));
}
function getMultiplier(PoolInfo storage pool) internal view returns (uint256) {
uint256 from = pool.lastRewardtime;
uint256 to = block.timestamp < pool.endtime ? block.timestamp : pool.endtime;
if (from >= to) {
return 0;
}
return to.sub(from);
}
function massUpdatePools() public {
uint256 length = poolinfo.length;
for (uint256 pid = 0; pid < length; pid++) {
updatePool(pid);
}
}
function updatePool(uint256 _pid) public validatePool(_pid) {
PoolInfo storage pool = poolinfo[_pid];
if (block.timestamp <= pool.lastRewardtime || pool.lastRewardtime > pool.endtime) {
return;
}
uint256 totalStake = pool.totalStake.add(pool.extraPower);
if (totalStake == 0) {
pool.lastRewardtime = block.timestamp <= pool.endtime ? block.timestamp : pool.endtime;
return;
}
uint256 multiplier = getMultiplier(pool);
uint256 BOTSReward = multiplier.mul(pool.BOTSPertime);
pool.accBOTSPerShare = pool.accBOTSPerShare.add(BOTSReward.mul(1e18).div(totalStake));
pool.lastRewardtime = block.timestamp < pool.endtime ? block.timestamp : pool.endtime;
}
function pendingBOTS(uint256 _pid, address _user) public view validatePool(_pid) returns (uint256) {
PoolInfo storage pool = poolinfo[_pid];
UserInfo storage user = users[_pid][_user];
uint256 accBOTSPerShare = pool.accBOTSPerShare;
uint256 totalStake = pool.totalStake.add(pool.extraPower);
if (block.timestamp > pool.lastRewardtime && totalStake > 0) {
uint256 multiplier = getMultiplier(pool);
uint256 BOTSReward = multiplier.mul(pool.BOTSPertime);
accBOTSPerShare = accBOTSPerShare.add(BOTSReward.mul(1e18).div(totalStake));
}
return user.pending.add(user.amount.add(user.extraPower).mul(accBOTSPerShare).div(1e18)).sub(user.rewardDebt);
}
function deposit(uint256 _pid, uint256 _amount, uint256 _booster) public payable validatePool(_pid){
address _owner = msg.sender;
require(!_owner.isContract(), "the user is contract");
PoolInfo storage pool = poolinfo[_pid];
UserInfo storage user = users[_pid][msg.sender];
uint256 power;
updatePool(_pid);
if (!user.status){
user.depositTime = block.timestamp;
}
if (address(pool.token) == address(0)){
_amount = msg.value;
}else{
pool.token.safeTransferFrom(_msgSender(), address(this), _amount);
}
if (_booster <= 4){
roBotNFT.stakeBoosterConsume(msg.sender,_booster);
user.boosterAmount = user.boosterAmount.add(_amount);
}
if (user.amount > 0) {
uint256 pending = user.amount.add(user.extraPower).mul(pool.accBOTSPerShare).div(1e18).sub(user.rewardDebt);
user.pending = user.pending.add(pending);
}
if (pool.token == BOTStoken){
stakeBOTSAmount = stakeBOTSAmount.add(_amount);
}
if (_booster == 0) {
power = _amount.mul(extraPowerZero).div(100);
}
if(_booster == 1){
power = _amount.mul(extraPowerOne).div(100);
}
if (_booster == 2){
power = _amount.mul(extraPowerTwo).div(100);
}
if (_booster == 3){
power = _amount.mul(extraPowerThree).div(100);
}
if (_booster == 4){
power = _amount.mul(extraPowerFour).div(100);
}
user.status = true;
pool.totalStake = pool.totalStake.add(_amount);
pool.extraPower = pool.extraPower.add(power);
user.extraPower = user.extraPower.add(power);
user.amount = user.amount.add(_amount);
user.rewardDebt = user.amount.add(user.extraPower).mul(pool.accBOTSPerShare).div(1e18);
emit Deposit(msg.sender, _pid, _amount);
}
function withdraw(uint256 _pid, uint256 _amount) public validatePool(_pid){
PoolInfo storage pool = poolinfo[_pid];
UserInfo storage user = users[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
uint256 power = user.extraPower;
updatePool(_pid);
uint256 pending = user.amount.add(user.extraPower).mul(pool.accBOTSPerShare).div(1e18).sub(user.rewardDebt);
user.pending = user.pending.add(pending);
user.amount = user.amount.sub(_amount);
if (user.amount < user.boosterAmount.div(2) && user.boosterAmount > 0) {
user.extraPower = 0;
pool.extraPower = pool.extraPower.sub(power);
user.boosterAmount = 0;
}
user.rewardDebt = user.amount.add(user.extraPower).mul(pool.accBOTSPerShare).div(1e18);
pool.totalStake = pool.totalStake.sub(_amount);
if (pool.token == BOTStoken){
stakeBOTSAmount = stakeBOTSAmount.sub(_amount);
}
if (address(pool.token) == address(0)){
msg.sender.transfer(_amount);
}else{
pool.token.safeTransfer(msg.sender, _amount);
}
emit Withdraw(msg.sender, _pid, _amount);
}
function claimStakingReward(uint256 _pid) public validatePool(_pid) {
PoolInfo storage pool = poolinfo[_pid];
UserInfo storage user = users[_pid][msg.sender];
updatePool(_pid);
uint256 _releaseAmount;
uint256 burnAmount;
uint256 pending = user.pending.add(user.amount.add(user.extraPower).mul(pool.accBOTSPerShare).div(1e18).sub(user.rewardDebt));
if (fee > 0 && pending > 0){
burnAmount = pending.mul(fee).div(100);
BOTStoken.burn(burnAmount);
pending = pending.sub(burnAmount);
}
if (block.timestamp.sub(user.depositTime).div(86400) >= 180){
_releaseAmount = getAvailablelockAmount(msg.sender, _pid);
if (_releaseAmount > 0) {
safeBOTSTransfer(msg.sender, pending.add(_releaseAmount));
user.claimedlockAmount = user.claimedlockAmount.add(_releaseAmount);
}else{
safeBOTSTransfer(msg.sender, pending);
}
}else{
uint256 lockAmount = pending.mul(lockpercent).div(100);
user.lockTotalAmount = user.lockTotalAmount.add(lockAmount);
_releaseAmount = getAvailablelockAmount(msg.sender, _pid);
safeBOTSTransfer(msg.sender, pending.add(_releaseAmount).sub(lockAmount));
user.claimedlockAmount = user.claimedlockAmount.add(_releaseAmount);
}
user.pending = 0;
user.rewardDebt = user.amount.add(user.extraPower).mul(pool.accBOTSPerShare).div(1e18);
emit ReclaimStakingReward(msg.sender, pending);
}
function getLockAmount(address _user, uint256 _pid) public view validatePool(_pid) returns(uint256) {
UserInfo storage user = users[_pid][_user];
return user.lockTotalAmount.sub(user.claimedlockAmount);
}
function getAvailablelockAmount(address _user, uint256 _pid) public view validatePool(_pid) returns(uint256) {
UserInfo storage user = users[_pid][_user];
uint256 day = block.timestamp.sub(user.depositTime).div(86400);
if (user.lockTotalAmount == 0 || day == 0) {
return 0;
}
if (day < 180){
uint256 releaseAmount = user.lockTotalAmount.mul(day).div(releasePeriod).sub(user.claimedlockAmount);
return releaseAmount;
}
return user.lockTotalAmount.sub(user.claimedlockAmount);
}
function safeBOTSTransfer(address _to, uint256 _amount) internal {
uint256 BOTSBalance = BOTStoken.balanceOf(address(this)).sub(stakeBOTSAmount);
require(BOTSBalance >= _amount, "no enough token");
BOTStoken.transfer(_to, _amount);
}
function() external payable{}
}
| 38,097 | 12,890 |
19d12678755644f4addde67bea44dc6def47763cc475a45cf21531ab597866dd
| 33,613 |
.sol
|
Solidity
| false |
319124529
|
HikaruHokkyokusei/RTK-Swap-Contract
|
facb9038745d0e32fc7b021ac547f15ebf31d290
|
RTK_SwapContract.sol
| 4,636 | 16,867 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.2;
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
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;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract RTK_SwapContract {
address private owner;
mapping(uint256 => address) private _Token_RTKL;
mapping(uint256 => uint256) private _RTKLX_ExtCirculation;
mapping(uint256 => uint256) private _RTKLX_InitialSupply;
address private _Token_AMMO;
event OwnerSet(address indexed oldOwner, address indexed newOwner);
// modifier to check if caller is owner
modifier OwnerOnly() {
require(msg.sender == owner, "Caller is not owner");
_;
}
constructor(address RTK, address RTKL2, address RTKL3, address RTKL4, address RTKL5, address AMMO) public {
owner = msg.sender;
_Token_RTKL[0] = RTK;
_Token_RTKL[1] = RTKL2;
_Token_RTKL[2] = RTKL3;
_Token_RTKL[3] = RTKL4;
_Token_RTKL[4] = RTKL5;
_Token_AMMO = AMMO;
_RTKLX_ExtCirculation[0] = ERC20(RTK).totalSupply();
_RTKLX_ExtCirculation[1] = 0;
_RTKLX_ExtCirculation[2] = 0;
_RTKLX_ExtCirculation[3] = 0;
_RTKLX_ExtCirculation[4] = 0;
_RTKLX_InitialSupply[1] = ERC20(RTKL2).totalSupply();
_RTKLX_InitialSupply[2] = ERC20(RTKL3).totalSupply();
_RTKLX_InitialSupply[3] = ERC20(RTKL4).totalSupply();
_RTKLX_InitialSupply[4] = ERC20(RTKL5).totalSupply();
emit OwnerSet(address(0), owner);
}
function changeOwner(address newOwner) public OwnerOnly {
emit OwnerSet(owner, newOwner);
owner = newOwner;
}
function getOwner() external view returns (address) {
return owner;
}
function changeTokenAddresses(address RTK, address RTKL2, address RTKL3, address RTKL4, address RTKL5, address AMMO) public OwnerOnly {
_Token_RTKL[0] = RTK;
_Token_RTKL[1] = RTKL2;
_Token_RTKL[2] = RTKL3;
_Token_RTKL[3] = RTKL4;
_Token_RTKL[4] = RTKL5;
_Token_AMMO = AMMO;
}
// Function to get amount of minimum required AMMO in the contract
function getMinimumRequiredAMMOAmount() public view returns (uint256) {
uint256 netUnburntExtCirculation = 0;
uint256 amountOfTokensBurnt;
for(uint i = 1; i <= 4; i++) {
amountOfTokensBurnt = _RTKLX_InitialSupply[i] - ERC20(_Token_RTKL[i]).totalSupply();
if(amountOfTokensBurnt <= _RTKLX_ExtCirculation[i]) {
netUnburntExtCirculation += (_RTKLX_ExtCirculation[i] - amountOfTokensBurnt)*(i);
}
}
return netUnburntExtCirculation;
}
// Function to get amount of minimum required RTK in the contract
function getMinimumRequiredRTKAmount() public view returns (uint256) {
uint256 netUnburntExtCirculation = 0;
uint256 amountOfTokensBurnt;
for(uint i = 1; i <= 4; i++) {
amountOfTokensBurnt = _RTKLX_InitialSupply[i] - ERC20(_Token_RTKL[i]).totalSupply();
if(amountOfTokensBurnt <= _RTKLX_ExtCirculation[i]) {
netUnburntExtCirculation += (_RTKLX_ExtCirculation[i] - amountOfTokensBurnt);
}
}
return netUnburntExtCirculation;
}
// In order to facilitate conversion of RTKLX into RTK for all the UNBURNED RTKLX in the circulation.
function pullOutExcessAMMO(address to, uint256 amount) public OwnerOnly returns (bool) {
ERC20 AMMOToken = ERC20(_Token_AMMO);
require (amount > 0,
"Cannot pull out 0");
require (AMMOToken.balanceOf(address(this)) >= amount,
"Insufficient AMMO balance in the contract");
require (AMMOToken.balanceOf(address(this)) - amount >= getMinimumRequiredAMMOAmount(),
"Cannot withdraw an amount that leaves swap contract deficient of minimum required AMMO");
return AMMOToken.transfer(to, amount);
}
// In order to facilitate conversion of RTKLX into RTK for all the UNBURNED RTKLX in the circulation.
function pullOutExcessRTK(address to, uint256 amount) public OwnerOnly returns (bool) {
ERC20 RTKToken = ERC20(_Token_RTKL[0]);
require (amount > 0,
"Cannot pull out 0");
require (RTKToken.balanceOf(address(this)) >= amount,
"Insufficient RTK balance in the contract");
require ((RTKToken.balanceOf(address(this)) - amount) >= getMinimumRequiredRTKAmount(),
"Cannot withdraw an amount that leaves swap contract deficient of minimum required RTK");
return RTKToken.transfer(to, amount);
}
function convertRTKIntoRTKLX(address to, uint256 amount, uint256 X) public returns (bool) {
require ((X >= 2 && X <= 5),
"Invalid value of X. X can only be 2, 3, 4, 5");
require (amount > 0,
"Cannot convert 0");
ERC20 AMMOToken = ERC20(_Token_AMMO);
ERC20 RTKToken = ERC20(_Token_RTKL[0]);
ERC20 RTKLXToken = ERC20(_Token_RTKL[X-1]);
require (RTKLXToken.balanceOf(address(this)) >= amount,
"Insufficeint RTKLX Token balance in the contract for the given value of X");
require (RTKToken.allowance(msg.sender, address(this)) >= amount,
"Allowance Lower than required for RTKToken");
require (AMMOToken.allowance(msg.sender, address(this)) >= ((X-1)*amount),
"Allowance Lower than required for bulletToken");
if(AMMOToken.transferFrom(msg.sender, address(this), ((X-1)*amount))) {
if(RTKToken.transferFrom(msg.sender, address(this), amount)) {
if(RTKLXToken.transfer(to, amount)) {
_RTKLX_ExtCirculation[X-1] += amount;
return true;
} else {
return false;
}
} else {
AMMOToken.transfer(msg.sender, (X-1)*amount);
return false;
}
} else {
return false;
}
}
function convertRTKLXIntoRTK(address to, uint256 amount, uint256 X) public returns (bool) {
require ((X >= 2 && X <= 5),
"Invalid value of X. X can only be 2, 3, 4, 5");
require (amount > 0,
"Cannot convert 0");
ERC20 RTKToken = ERC20(_Token_RTKL[0]);
ERC20 AMMOToken = ERC20 (_Token_AMMO);
ERC20 RTKLXToken = ERC20(_Token_RTKL[X-1]);
require (RTKToken.balanceOf(address(this)) >= amount,
"Insufficeint RTK Token balance in the contract");
require (AMMOToken.balanceOf(address(this)) >= amount*(X-1),
"insufficient AMMO token balance in the contract");
require (RTKLXToken.allowance(msg.sender, address(this)) >= amount,
"Allowance Lower than required for RTKToken");
if(RTKLXToken.transferFrom(msg.sender, address(this), amount)) {
if(_RTKLX_ExtCirculation[X-1] >= amount) {
_RTKLX_ExtCirculation[X-1] -= amount;
} else {
_RTKLX_ExtCirculation[X-1] = 0;
}
if(RTKToken.transfer(to, amount)) {
return AMMOToken.transfer(to, (X-1)*amount);
} else {
return false;
}
} else {
return false;
}
}
}
| 247,863 | 12,891 |
df8ef27c832e9ea4b4e3e722d9641239e6238d4db7ed1d62c689c3854c4f1650
| 39,272 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/82/8266f265466296768cba195c64cf9ddfd8edc97b_foxfinance.sol
| 4,970 | 19,708 |
// http://t.me/Fox_Financee
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address _owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash
= 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 1000000;
string private _name = "Fox Finance";
string private _symbol = "FOX";
uint8 private _decimals = 18;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function 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"));
}
}
// foxtoken with Governance.
contract foxfinance is BEP20("Fox Finance", "FOX") {
/// @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 => uint256) 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,
uint256 previousBalance,
uint256 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,
uint256 nonce,
uint256 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, uint256 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(uint256 n, string memory errorMessage)
internal
pure
returns (uint32)
{
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint256) {
uint256 chainId;
assembly {
chainId := chainid()
}
return chainId;
}
}
| 324,766 | 12,892 |
7c4f843410977f0f2daf99ab0b98eb2e5e6c34bdcc20547a884f7825428fbb34
| 19,334 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TA/TA4amp7zLPRbi2p527k65uMSE1U2hN3AGm_InvestmentClubV1.sol
| 4,711 | 18,170 |
//SourceUnit: contract_30_11_2020.sol
pragma solidity 0.5.12;
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;
}
function inc(uint a) internal pure returns(uint) {
return(add(a, 1));
}
function dec(uint a) internal pure returns(uint) {
return(sub(a, 1));
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = msg.sender;
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() private view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() private onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) private onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Pausable is Ownable{
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() private view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() private onlyOwner whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() private onlyOwner whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract InvestmentClubV1 is Pausable
{
using SafeMath for uint256;
struct Deposit {
uint256 depositTime;
uint256 lastDepositTime;
uint256 amount;
uint256 validUntil;
}
struct DepositHistory {
uint256 depositTime;
uint256 lastDepositTime;
uint256 amount;
uint256 validUntil;
bool IsCollect;
}
struct WithdrawTable {
uint256 withdrawTime;
uint256 amount;
}
struct PlayerReferral {
uint256 createDate;
address referral;
uint256 depositAmount;
uint256 withdrawAmount;
uint256 commission;
}
struct Player {
Deposit[] deposits;
DepositHistory[] deposithistory;
WithdrawTable[] withdrawtable;
uint256 withdrawns;
uint256 depositAmount;
uint256 balance;
uint256 validUntil;
uint256 YouCanWithdraw;
PlayerReferral[] playerReferrals;
address payable usersReferral;
bool isFirstDeposit;
uint256 MytotalCountReferral;
uint256 MytotalReferralEarn;
uint256 MytotalWithdrawn;
}
uint256[] private PERIOD = [200 days]; //max profit days
uint256 constant private MIN_DEPOSIT = 5000000; // minimum deposit 50 TRX
uint256 constant private TEAM_PERCENT = 10; //10%
uint256 private totalDeposit;
address payable private team_wallet = address(0x412F24D0920A7B058093279A628364CEE1A431E775);
uint256[] private RATE_DIVIDER = [8640000]; //profit per second 86400(1 day in seconds) * 100 (1% per day) =K 8640000
uint256[] private REF_PERCENT = [5];// referral deposit 5%, withdraw 5%
uint256 public totalWithdrawn;
mapping(address => Player) public users;
event Deposits(address indexed user, uint256 amount);
event adminFee(address indexed addr, address indexed wallet, uint256 amount);
event RefFee(address indexed addr, address indexed referral, uint256 amount);
event Fee(address indexed addr, address indexed referrer, uint256 amount);
event Withdrawn(address indexed addr, uint256 amount);
uint256 public totalUsers;
uint256 public totalCountReferral;
uint256 public totalReferralEarn;
function isExistReferral(address referral) view private returns (bool){
PlayerReferral[] storage user = users[referral].playerReferrals;
for (uint i; i< user.length;i++){
if (user[i].referral==msg.sender)
return true;
}
}
function isDeposited() public view returns(bool)
{ Player storage user = users[msg.sender];
if (user.isFirstDeposit == true) {
return true;
}
}
function UpdateReferralBalance(address referral,uint256 depositAmount, uint256 withdrawAmount, uint256 commission) private
{
if (msg.sender!=referral && referral!=team_wallet)
{
if (!isExistReferral(referral))
{
Player storage user = users[referral];
user.playerReferrals.push(PlayerReferral(now,msg.sender, depositAmount,withdrawAmount,commission));
totalCountReferral=totalCountReferral.add(1);
users[referral].MytotalCountReferral=users[referral].MytotalCountReferral.add(1);
users[referral].MytotalReferralEarn=users[referral].MytotalReferralEarn.add(commission);
}
else
{
Player storage user = users[referral];
PlayerReferral[] memory ref = user.playerReferrals;
uint256 i = 0;
while (i < ref.length){
PlayerReferral memory getRef = ref[i];
if (getRef.referral==msg.sender) {
PlayerReferral storage setRef = users[referral].playerReferrals[i];
setRef.depositAmount = setRef.depositAmount.add(depositAmount);
setRef.withdrawAmount = getRef.withdrawAmount.add(withdrawAmount);
setRef.commission = setRef.commission.add(commission);
}i++;
}
totalReferralEarn=totalReferralEarn.add(commission);
users[referral].MytotalReferralEarn=users[referral].MytotalReferralEarn.add(commission);
}
}
}
function deposit(address payable referral) public payable whenNotPaused
{
uint256 amount = msg.value;
require(amount >= 1, "Your investment amount is less than the minimum amount!");
address addr = msg.sender;
Player storage user = users[msg.sender];
Player storage getRef = users[referral];
if (users[addr].deposits.length==0)
{
totalUsers = totalUsers.add(1);
}
//Enable option transfer to the referall partner
if (users[addr].usersReferral==address(0))
{
if (getRef.isFirstDeposit==false)
{
user.usersReferral = team_wallet;
team_wallet.transfer(amount.mul(TEAM_PERCENT.add(REF_PERCENT[0])).div(100));
}
else
{
user.usersReferral = referral;
team_wallet.transfer(amount.mul(TEAM_PERCENT).div(100));
referral.transfer(amount.mul(REF_PERCENT[0]).div(100));
UpdateReferralBalance(referral, amount, 0, amount.mul(REF_PERCENT[0]).div(100));
}
}
else
{ address payable SendRef = user.usersReferral;
team_wallet.transfer(amount.mul(TEAM_PERCENT).div(100));
SendRef.transfer(amount.mul(REF_PERCENT[0]).div(100));
UpdateReferralBalance(SendRef, amount, 0, amount.mul(REF_PERCENT[0]).div(100));
}
user.deposits.push(Deposit(now, now, amount, now.add(PERIOD[0])));
user.deposithistory.push(DepositHistory(now, now, amount, now.add(PERIOD[0]),false));
user.depositAmount = users[addr].depositAmount.add(amount);
user.validUntil = now.add(PERIOD[0]);
totalDeposit = totalDeposit.add(amount);
user.isFirstDeposit=true;
emit Deposits(addr, amount);
}
function withdraw() public{
address payable addr = msg.sender;
address payable referral=users[addr].usersReferral;
uint256 value = collect();
uint256 WithdrawFromAmount = value < address(this).balance ? value: (address(this).balance).sub(address(this).balance.mul(REF_PERCENT[0]).div(100)); //(address(this).balance);//.value.mul(REF_PERCENT[0]).div(100));
users[addr].withdrawtable.push(WithdrawTable(now,WithdrawFromAmount));
addr.transfer(WithdrawFromAmount);
users[addr].YouCanWithdraw = value.sub(WithdrawFromAmount);
UpdateReferralBalance(referral, 0, value, value.mul(REF_PERCENT[0]).div(100));
referral.transfer(WithdrawFromAmount.mul(REF_PERCENT[0]).div(100));
totalWithdrawn=totalWithdrawn.add(WithdrawFromAmount);
users[addr].MytotalWithdrawn=users[addr].MytotalWithdrawn.add(WithdrawFromAmount);
emit Withdrawn(addr, WithdrawFromAmount);
}
function collect() private returns(uint256){
address addr= msg.sender;
Deposit[] storage invests = users[addr].deposits;
uint256 profit = users[addr].YouCanWithdraw;
uint256 i = 0;
uint256 timeSpent=0;
while (i < invests.length){
Deposit storage invest = invests[i];
if (invest.lastDepositTime < invest.depositTime.add(PERIOD[0])){
uint256 remainedTime = PERIOD[0].sub(invest.lastDepositTime.sub(invest.depositTime));
if (remainedTime > 0){
timeSpent = now.sub(invest.lastDepositTime);
if (remainedTime <= timeSpent){
timeSpent = remainedTime;
//Update deposit history
DepositHistory[] storage invests_history = users[addr].deposithistory;
invests_history[i].IsCollect=true;
}
invest.lastDepositTime = now;
profit = profit.add(invest.amount.mul(timeSpent).div(RATE_DIVIDER[0]));
}
}
i++;
}
return (profit);
}
function getUserCollectWithdraw () public view returns(uint256) {
Deposit[] storage invests = users[msg.sender].deposits;
uint256 profit = users[msg.sender].YouCanWithdraw;
uint256 i = 0;
uint256 timeSpent=0;
while (i < invests.length){
Deposit storage invest = invests[i];
if (invest.lastDepositTime < invest.depositTime.add(PERIOD[0])){
uint256 remainedTime = PERIOD[0].sub(invest.lastDepositTime.sub(invest.depositTime));
if (remainedTime > 0){
timeSpent = now.sub(invest.lastDepositTime);
if (remainedTime <= timeSpent){
timeSpent = remainedTime;
}
}
profit += (invest.amount.mul(timeSpent).div(RATE_DIVIDER[0]));
}
i++;
}
return profit;
}
function getReferrals() public view returns (uint256[] memory, address[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
Player storage user = users[msg.sender];
PlayerReferral[] memory ref = user.playerReferrals;
uint256[] memory createDate = new uint256[](ref.length);
address[] memory referralAddress = new address[](ref.length);
uint256[] memory depositAmount = new uint256[](ref.length);
uint256[] memory withdrawAmount = new uint256[](ref.length);
uint256[] memory commission = new uint256[](ref.length);
uint256 i = 0;
while (i < ref.length){
PlayerReferral memory getRef = ref[i];
if (getRef.depositAmount > 0 || getRef.withdrawAmount>0) {
createDate[i] = getRef.createDate;
referralAddress[i] = getRef.referral;
depositAmount[i] = getRef.depositAmount;
withdrawAmount[i] = getRef.withdrawAmount;
commission[i] = getRef.commission;
}i++;
}
return (createDate,referralAddress,depositAmount,withdrawAmount,commission);
}
function getPlayerDeposit() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory,uint256[] memory) {
Deposit[] memory invests = users[msg.sender].deposits;
uint256[] memory baseTimes = new uint256[](invests.length);
uint256[] memory lastCollectedTimes = new uint256[](invests.length);
uint256[] memory values = new uint256[](invests.length);
uint256[] memory calcSeconds = new uint256[](invests.length);
uint256[] memory profit = new uint256[](invests.length);
uint256[] memory validUntil = new uint256[](invests.length);
uint256 i = 0;
uint256 timeSpent = 0;
while (i < invests.length){
Deposit memory invest = invests[i];
if (invest.lastDepositTime < invest.depositTime.add(PERIOD[0])){
uint256 remainedTime = PERIOD[0].sub(invest.lastDepositTime.sub(invest.depositTime));
if (remainedTime > 0){
timeSpent=now.sub(invest.lastDepositTime);
if (remainedTime <= timeSpent){
timeSpent = remainedTime;
}
}
baseTimes[i] = invest.depositTime;
lastCollectedTimes[i] = invest.lastDepositTime;
values[i] = invest.amount;
calcSeconds[i] = timeSpent;
profit[i] = (invest.amount * timeSpent).div(RATE_DIVIDER[0]);
validUntil[i] = invest.depositTime.add(PERIOD[0]);
}i++;
}
return (baseTimes, lastCollectedTimes, values, calcSeconds,profit,validUntil);
}
function getPlayerDepositHistory() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
DepositHistory[] memory invests = users[msg.sender].deposithistory;
uint256[] memory baseTimes = new uint256[](invests.length);
uint256[] memory values = new uint256[](invests.length);
uint256[] memory profit = new uint256[](invests.length);
uint256[] memory validUntil = new uint256[](invests.length);
bool[] memory IsCollect = new bool[](invests.length);
uint256 i = 0;
uint256 timeSpent = 0;
while (i < invests.length){
DepositHistory memory invest = invests[i];
if (invest.lastDepositTime < invest.depositTime.add(PERIOD[0])){
uint256 remainedTime = PERIOD[0].sub(invest.lastDepositTime.sub(invest.depositTime));
if (remainedTime > 0){
timeSpent=now.sub(invest.lastDepositTime);
if (remainedTime <= timeSpent){
timeSpent = remainedTime;
}
}
baseTimes[i] = invest.depositTime;
values[i] = invest.amount;
profit[i] = (invest.amount * timeSpent).div(RATE_DIVIDER[0]);
validUntil[i] = invest.depositTime.add(PERIOD[0]);
IsCollect[i] = invest.IsCollect;
}i++;
}
return (baseTimes, values, profit,validUntil,IsCollect);
}
function getPlayerWithdrawHistory() public view returns (uint256[] memory, uint256[] memory,uint256[] memory) {
WithdrawTable[] memory invests = users[msg.sender].withdrawtable;
uint256[] memory withdrawTime = new uint256[](invests.length);
uint256[] memory values = new uint256[](invests.length);
uint256[] memory lastime = new uint256[](invests.length);
uint256 i = 0;
while (i < invests.length){
WithdrawTable memory invest = invests[i];
if (invest.amount>0)
{
withdrawTime[i] = invest.withdrawTime;
values[i] = invest.amount;
}i++;
}
return (withdrawTime,values,lastime);
}
function getContractBalance() public view returns(uint256)
{
return address(this).balance;
}
function getTotalStats() public view returns (uint256[] memory) {
uint256[] memory combined = new uint256[](10);
combined[0] = totalDeposit;
combined[1] = address(this).balance;
combined[2] = totalUsers;
combined[3] = totalCountReferral;
combined[4] = totalReferralEarn;
combined[5] = users[msg.sender].MytotalCountReferral;
combined[6] = users[msg.sender].MytotalReferralEarn;
combined[7] = totalWithdrawn;
combined[8] = users[msg.sender].depositAmount;
combined[9] = users[msg.sender].MytotalWithdrawn;
return combined;
}
}
| 301,235 | 12,893 |
923416ec29d13d17cc09de1adf836f06a4bc6bdb8b8e2e9b718814c84a7d1875
| 20,410 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xce0af8e766de11067c033c4a8916462d2ced758e.sol
| 5,409 | 20,191 |
pragma solidity =0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address tokenOwner) external view returns (uint balance);
function allowance(address tokenOwner, address spender) external view returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed from, address indexed to);
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), owner);
}
modifier onlyOwner {
require(msg.sender == owner, "Ownable: Caller is not the owner");
_;
}
function transferOwnership(address transferOwner) public onlyOwner {
require(transferOwner != newOwner);
newOwner = transferOwner;
}
function acceptOwnership() virtual public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract GNBU is Ownable, Pausable {
string public constant name = "Nimbus Governance Token";
string public constant symbol = "GNBU";
uint8 public constant decimals = 18;
uint96 public totalSupply = 100_000_000e18; // 100 million GNBU
mapping (address => mapping (address => uint96)) internal allowances;
mapping (address => uint96) private _unfrozenBalances;
mapping (address => uint32) private _vestingNonces;
mapping (address => mapping (uint32 => uint96)) private _vestingAmounts;
mapping (address => mapping (uint32 => uint96)) private _unvestedAmounts;
mapping (address => mapping (uint32 => uint)) private _vestingReleaseStartDates;
mapping (address => bool) public vesters;
uint96 private vestingFirstPeriod = 60 days;
uint96 private vestingSecondPeriod = 152 days;
address[] public supportUnits;
uint public supportUnitsCnt;
mapping (address => address) public delegates;
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
mapping (address => uint32) public numCheckpoints;
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
mapping (address => uint) public nonces;
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
event Unvest(address user, uint amount);
constructor() {
_unfrozenBalances[owner] = uint96(totalSupply);
emit Transfer(address(0), owner, totalSupply);
}
function freeCirculation() external view returns (uint) {
uint96 systemAmount = _unfrozenBalances[owner];
for (uint i; i < supportUnits.length; i++) {
systemAmount = add96(systemAmount, _unfrozenBalances[supportUnits[i]], "GNBU::freeCirculation: adding overflow");
}
return sub96(totalSupply, systemAmount, "GNBU::freeCirculation: amount exceed totalSupply");
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external whenNotPaused returns (bool) {
uint96 amount;
if (rawAmount == uint(2 ** 256 - 1)) {
amount = uint96(2 ** 96 - 1);
} else {
amount = safe96(rawAmount, "GNBU::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function permit(address owner, address spender, uint rawAmount, uint deadline, uint8 v, bytes32 r, bytes32 s) external whenNotPaused {
uint96 amount;
if (rawAmount == uint(2 ** 256 - 1)) {
amount = uint96(2 ** 96 - 1);
} else {
amount = safe96(rawAmount, "GNBU::permit: amount exceeds 96 bits");
}
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "GNBU::permit: invalid signature");
require(signatory == owner, "GNBU::permit: unauthorized");
require(block.timestamp <= deadline, "GNBU::permit: signature expired");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function balanceOf(address account) public view returns (uint) {
uint96 amount = _unfrozenBalances[account];
if (_vestingNonces[account] == 0) return amount;
for (uint32 i = 1; i <= _vestingNonces[account]; i++) {
uint96 unvested = sub96(_vestingAmounts[account][i], _unvestedAmounts[account][i], "GNBU::balanceOf: unvested exceed vested amount");
amount = add96(amount, unvested, "GNBU::balanceOf: overflow");
}
return amount;
}
function availableForUnvesting(address user) external view returns (uint unvestAmount) {
if (_vestingNonces[user] == 0) return 0;
for (uint32 i = 1; i <= _vestingNonces[user]; i++) {
if (_vestingAmounts[user][i] == _unvestedAmounts[user][i]) continue;
if (_vestingReleaseStartDates[user][i] > block.timestamp) break;
uint toUnvest = mul96((block.timestamp - _vestingReleaseStartDates[user][i]), (_vestingAmounts[user][i])) / vestingSecondPeriod;
if (toUnvest > _vestingAmounts[user][i]) {
toUnvest = _vestingAmounts[user][i];
}
toUnvest -= _unvestedAmounts[user][i];
unvestAmount += toUnvest;
}
}
function availableForTransfer(address account) external view returns (uint) {
return _unfrozenBalances[account];
}
function vestingInfo(address user, uint32 nonce) external view returns (uint vestingAmount, uint unvestedAmount, uint vestingReleaseStartDate) {
vestingAmount = _vestingAmounts[user][nonce];
unvestedAmount = _unvestedAmounts[user][nonce];
vestingReleaseStartDate = _vestingReleaseStartDates[user][nonce];
}
function vestingNonces(address user) external view returns (uint lastNonce) {
return _vestingNonces[user];
}
function transfer(address dst, uint rawAmount) external whenNotPaused returns (bool) {
uint96 amount = safe96(rawAmount, "GNBU::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external whenNotPaused returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "GNBU::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(2 ** 96 - 1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "GNBU::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public whenNotPaused {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public whenNotPaused {
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), "GNBU::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "GNBU::delegateBySig: invalid nonce");
require(block.timestamp <= expiry, "GNBU::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function unvest() external whenNotPaused returns (uint96 unvested) {
require (_vestingNonces[msg.sender] > 0, "GNBU::unvest:No vested amount");
for (uint32 i = 1; i <= _vestingNonces[msg.sender]; i++) {
if (_vestingAmounts[msg.sender][i] == _unvestedAmounts[msg.sender][i]) continue;
if (_vestingReleaseStartDates[msg.sender][i] > block.timestamp) break;
uint96 toUnvest = mul96((block.timestamp - _vestingReleaseStartDates[msg.sender][i]), _vestingAmounts[msg.sender][i]) / vestingSecondPeriod;
if (toUnvest > _vestingAmounts[msg.sender][i]) {
toUnvest = _vestingAmounts[msg.sender][i];
}
uint96 totalUnvestedForNonce = toUnvest;
toUnvest = sub96(toUnvest, _unvestedAmounts[msg.sender][i], "GNBU::unvest: already unvested amount exceeds toUnvest");
unvested = add96(unvested, toUnvest, "GNBU::unvest: adding overflow");
_unvestedAmounts[msg.sender][i] = totalUnvestedForNonce;
}
_unfrozenBalances[msg.sender] = add96(_unfrozenBalances[msg.sender], unvested, "GNBU::unvest: adding overflow");
emit Unvest(msg.sender, unvested);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "GNBU::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = _unfrozenBalances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "GNBU::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "GNBU::_transferTokens: cannot transfer to the zero address");
_unfrozenBalances[src] = sub96(_unfrozenBalances[src], amount, "GNBU::_transferTokens: transfer amount exceeds balance");
_unfrozenBalances[dst] = add96(_unfrozenBalances[dst], amount, "GNBU::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "GNBU::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew = add96(dstRepOld, amount, "GNBU::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "GNBU::_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 _vest(address user, uint96 amount) private {
uint32 nonce = ++_vestingNonces[user];
_vestingAmounts[user][nonce] = amount;
_vestingReleaseStartDates[user][nonce] = block.timestamp + vestingFirstPeriod;
_unfrozenBalances[owner] = sub96(_unfrozenBalances[owner], amount, "GNBU::_vest: exceeds owner balance");
emit Transfer(owner, user, amount);
}
function burnTokens(uint rawAmount) public onlyOwner returns (bool success) {
uint96 amount = safe96(rawAmount, "GNBU::burnTokens: amount exceeds 96 bits");
require(amount <= _unfrozenBalances[owner]);
_unfrozenBalances[owner] = sub96(_unfrozenBalances[owner], amount, "GNBU::burnTokens: transfer amount exceeds balance");
totalSupply = sub96(totalSupply, amount, "GNBU::burnTokens: transfer amount exceeds total supply");
emit Transfer(owner, address(0), amount);
return true;
}
function vest(address user, uint rawAmount) external {
require (vesters[msg.sender], "GNBU::vest: not vester");
uint96 amount = safe96(rawAmount, "GNBU::vest: amount exceeds 96 bits");
_vest(user, amount);
}
function multisend(address[] memory to, uint[] memory values) public onlyOwner returns (uint) {
require(to.length == values.length);
require(to.length < 100);
uint sum;
for (uint j; j < values.length; j++) {
sum += values[j];
}
uint96 _sum = safe96(sum, "GNBU::transfer: amount exceeds 96 bits");
_unfrozenBalances[owner] = sub96(_unfrozenBalances[owner], _sum, "GNBU::_transferTokens: transfer amount exceeds balance");
for (uint i; i < to.length; i++) {
_unfrozenBalances[to[i]] = add96(_unfrozenBalances[to[i]], uint96(values[i]), "GNBU::_transferTokens: transfer amount exceeds balance");
emit Transfer(owner, to[i], values[i]);
}
return(to.length);
}
function multivest(address[] memory to, uint[] memory values) external onlyOwner returns (uint) {
require(to.length == values.length);
require(to.length < 100);
uint sum;
for (uint j; j < values.length; j++) {
sum += values[j];
}
uint96 _sum = safe96(sum, "GNBU::multivest: amount exceeds 96 bits");
_unfrozenBalances[owner] = sub96(_unfrozenBalances[owner], _sum, "GNBU::multivest: transfer amount exceeds balance");
for (uint i; i < to.length; i++) {
uint32 nonce = ++_vestingNonces[to[i]];
_vestingAmounts[to[i]][nonce] = uint96(values[i]);
_vestingReleaseStartDates[to[i]][nonce] = block.timestamp + vestingFirstPeriod;
emit Transfer(owner, to[i], values[i]);
}
return(to.length);
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return IERC20(tokenAddress).transfer(owner, tokens);
}
function updateVesters(address vester, bool isActive) external onlyOwner {
vesters[vester] = isActive;
}
function acceptOwnership() public override {
require(msg.sender == newOwner);
uint96 amount = _unfrozenBalances[owner];
_transferTokens(owner, newOwner, amount);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
function updateSupportUnitAdd(address newSupportUnit) external onlyOwner {
for (uint i; i < supportUnits.length; i++) {
require (supportUnits[i] != newSupportUnit, "GNBU::updateSupportUnitAdd: support unit exists");
}
supportUnits.push(newSupportUnit);
supportUnitsCnt++;
}
function updateSupportUnitRemove(uint supportUnitIndex) external onlyOwner {
supportUnits[supportUnitIndex] = supportUnits[supportUnits.length - 1];
supportUnits.pop();
supportUnitsCnt--;
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal view returns (uint) {
return block.chainid;
}
function mul96(uint96 a, uint96 b) internal pure returns (uint96) {
if (a == 0) {
return 0;
}
uint96 c = a * b;
require(c / a == b, "GNBU:mul96: multiplication overflow");
return c;
}
function mul96(uint256 a, uint96 b) internal pure returns (uint96) {
uint96 _a = safe96(a, "GNBU:mul96: amount exceeds uint96");
if (_a == 0) {
return 0;
}
uint96 c = _a * b;
require(c / _a == b, "GNBU:mul96: multiplication overflow");
return c;
}
}
| 275,799 | 12,894 |
49e2d544e5447cf2b17888cb2069421f68c122c0966253cdb12d16fcdc149fac
| 35,932 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/88/88494Edc824f21C48B3f3319AF6FfAF2146aA08a_ERC721Snapshot.sol
| 4,341 | 16,792 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
// Sources flattened with hardhat v2.8.3 https://hardhat.org
// File @openzeppelin/contracts/utils/Context.sol
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File @openzeppelin/contracts/access/IOwnable.sol
// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)
interface IOwnable {
function owner() external view returns (address);
function pushOwnership(address newOwner) external;
function pullOwnership() external;
function renounceOwnership() external;
function transferOwnership(address newOwner) external;
}
// File @openzeppelin/contracts/access/Ownable.sol
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is IOwnable, Context {
address private _owner;
address private _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual override returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function pushOwnership(address newOwner) public virtual override onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner);
_newOwner = newOwner;
}
function pullOwnership() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
function renounceOwnership() public virtual override onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual override onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File @openzeppelin/contracts/utils/introspection/IERC165.sol
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// File @openzeppelin/contracts/token/ERC721/IERC721.sol
// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes calldata data) external;
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
function transferFrom(address from,
address to,
uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
// File @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
function tokenByIndex(uint256 index) external view returns (uint256);
}
// File @openzeppelin/contracts/proxy/Clones.sol
// OpenZeppelin Contracts v4.4.1 (proxy/Clones.sol)
library Clones {
function clone(address implementation) internal returns (address instance) {
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
instance := create(0, ptr, 0x37)
}
require(instance != address(0), "ERC1167: create failed");
}
function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
instance := create2(0, ptr, 0x37, salt)
}
require(instance != address(0), "ERC1167: create2 failed");
}
function predictDeterministicAddress(address implementation,
bytes32 salt,
address deployer) internal pure returns (address predicted) {
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)
mstore(add(ptr, 0x38), shl(0x60, deployer))
mstore(add(ptr, 0x4c), salt)
mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))
predicted := keccak256(add(ptr, 0x37), 0x55)
}
}
function predictDeterministicAddress(address implementation, bytes32 salt)
internal
view
returns (address predicted)
{
return predictDeterministicAddress(implementation, salt, address(this));
}
}
// File @openzeppelin/contracts/utils/Address.sol
// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)
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);
}
}
}
}
// File @openzeppelin/contracts/proxy/utils/Initializable.sol
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/Initializable.sol)
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = _setInitializedVersion(1);
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
bool isTopLevelCall = _setInitializedVersion(version);
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(version);
}
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
_setInitializedVersion(type(uint8).max);
}
function _setInitializedVersion(uint8 version) private returns (bool) {
// If the contract is initializing we ignore whether _initialized is set in order to support multiple
// of initializers, because in other contexts the contract may have been reentered.
if (_initializing) {
require(version == 1 && !Address.isContract(address(this)),
"Initializable: contract is already initialized");
return false;
} else {
require(_initialized < version, "Initializable: contract is already initialized");
_initialized = version;
return true;
}
}
modifier whenNotInitialized() {
require(_initialized == 0, "Initializable: contract has been initialized");
_;
}
modifier whenInitialized() {
require(_initialized != 0, "Initializable: contract has not been initialized");
_;
}
}
// File contracts/interfaces/ICloneable.sol
interface ICloneable {
function clone() external returns (address);
function cloneDeterministic(bytes32 salt) external returns (address);
function isClone() external view returns (bool);
function parent() external view returns (address);
function predictDeterministicAddress(bytes32 salt) external view returns (address);
}
// File contracts/Cloneable/Cloneable.sol
abstract contract Cloneable is ICloneable, Initializable {
using Clones for address;
event CloneDeployed(address indexed parent, address indexed clone, bytes32 indexed salt);
function clone() public returns (address instance) {
if (address(this).code.length > 45) {
instance = address(this).clone();
emit CloneDeployed(address(this), instance, 0x0);
} else {
instance = ICloneable(parent()).clone();
emit CloneDeployed(parent(), instance, 0x0);
}
}
function cloneDeterministic(bytes32 salt) public returns (address instance) {
if (address(this).code.length > 45) {
instance = address(this).cloneDeterministic(salt);
emit CloneDeployed(address(this), instance, salt);
} else {
instance = ICloneable(parent()).cloneDeterministic(salt);
emit CloneDeployed(parent(), instance, salt);
}
}
function isClone() public view returns (bool) {
return (address(this).code.length == 45);
}
function parent() public view returns (address) {
if (address(this).code.length > 45) {
return address(this);
} else {
bytes memory _parent = new bytes(20);
address master;
uint256 k = 0;
for (uint256 i = 10; i <= 29; i++) {
_parent[k++] = address(this).code[i];
}
assembly {
master := mload(add(_parent, 20))
}
return master;
}
}
function predictDeterministicAddress(bytes32 salt) public view returns (address instance) {
if (address(this).code.length > 45) {
instance = address(this).predictDeterministicAddress(salt);
} else {
instance = ICloneable(parent()).predictDeterministicAddress(salt);
}
}
}
// File contracts/interfaces/IERC721Snapshot.sol
interface IERC721Snapshot is ICloneable {
function completed() external view returns (bool);
function initialize() external;
function initialize(IERC721Enumerable ERC721Contract) external;
function holders(uint256 index) external view returns (address);
function length() external view returns (uint256);
function snapshot(uint256 maxCount) external returns (bool);
function VERSION() external view returns (uint256);
}
// File contracts/ERC721Snapshot/ERC721Snapshot.sol
contract ERC721Snapshot is IERC721Snapshot, Cloneable, Ownable {
uint256 public constant VERSION = 2022042301;
event SnapshotCompleted(uint256 indexed count);
address[] public holders;
IERC721Enumerable public CONTRACT;
uint256 public snapshotPosition;
uint256 public totalSupply;
modifier notCompleted() {
require(!completed(), "Snapshot completed");
_;
}
constructor() {
_transferOwnership(address(0));
}
function completed() public view returns (bool) {
return snapshotPosition == totalSupply;
}
function initialize() public initializer {}
function initialize(IERC721Enumerable ERC721Contract) public initializer {
CONTRACT = ERC721Contract;
totalSupply = CONTRACT.totalSupply();
_transferOwnership(_msgSender());
}
function length() public view returns (uint256) {
return holders.length;
}
function snapshot(uint256 maxCount) public notCompleted onlyOwner returns (bool) {
_snapshot(maxCount);
if (completed()) {
emit SnapshotCompleted(holders.length);
return true;
}
return false;
}
function _snapshot(uint256 maxCount) internal {
uint256 count;
for (snapshotPosition; snapshotPosition < totalSupply; snapshotPosition++) {
if (++count > maxCount) {
break;
}
holders.push(CONTRACT.ownerOf(CONTRACT.tokenByIndex(snapshotPosition)));
}
}
}
| 317,637 | 12,895 |
9e46d715c8ff4d8b8e1b6ead151ec2fafe4b1357278fb5699e64d37fe8afe83c
| 29,778 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/39/397787a6c2947122d5ddb9dca0fad6062290de91_KimetsuYaiba.sol
| 3,395 | 12,617 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract KimetsuYaiba is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 80,537 | 12,896 |
993b62f2aa1879fa3bba853072d7f8f2290af958eee2991eedbe875a55249b04
| 14,676 |
.sol
|
Solidity
| false |
289165897
|
darwinia-network/darwinia-messages-sol
|
6f20950e445e6a63a96d0119c51679220ce2ff1d
|
contracts/verify/contracts/CompactMerkleProof.sol
| 3,028 | 12,971 |
// SPDX-License-Identifier: MIT
// Modified Merkle-Patricia Trie
//
// Note that for the following definitions, `|` denotes concatenation
//
// Branch encoding:
// NodeHeader | Extra partial key length | Partial Key | Value
// `NodeHeader` is a byte such that:
// most significant two bits of `NodeHeader`: 10 if branch w/o value, 11 if branch w/ value
// least significant six bits of `NodeHeader`: if len(key) > 62, 0x3f, otherwise len(key)
// `Extra partial key length` is included if len(key) > 63 and consists of the remaining key length
// `Partial Key` is the branch's key
//
// Leaf encoding:
// NodeHeader | Extra partial key length | Partial Key | Value
// `NodeHeader` is a byte such that:
// most significant two bits of `NodeHeader`: 01
// least significant six bits of `NodeHeader`: if len(key) > 62, 0x3f, otherwise len(key)
// `Extra partial key length` is included if len(key) > 63 and consists of the remaining key length
// `Partial Key` is the leaf's key
// `Value` is the leaf's SCALE encoded value
pragma solidity >=0.6.0 <0.7.0;
pragma experimental ABIEncoderV2;
import "@darwinia/contracts-utils/contracts/Input.sol";
import "@darwinia/contracts-utils/contracts/Memory.sol";
import "@darwinia/contracts-utils/contracts/Bytes.sol";
import "@darwinia/contracts-utils/contracts/Keccak.sol";
import "@darwinia/contracts-utils/contracts/Nibble.sol";
import "@darwinia/contracts-utils/contracts/Node.sol";
library CompactMerkleProof {
using Bytes for bytes;
using Keccak for bytes;
using Input for Input.Data;
uint8 internal constant NODEKIND_NOEXT_LEAF = 1;
uint8 internal constant NODEKIND_NOEXT_BRANCH_NOVALUE = 2;
uint8 internal constant NODEKIND_NOEXT_BRANCH_WITHVALUE = 3;
struct StackEntry {
bytes prefix; // The prefix is the nibble path to the node in the trie.
uint8 kind; // The type of the trie node.
bytes key; // The partail key of the trie node.
bytes value; // The value associated with this trie node.
Node.NodeHandle[16] children; // The child references to use in reconstructing the trie nodes.
uint8 childIndex; // The child index is in [0, NIBBLE_LENGTH],
bool isInline; // The trie node data less 32-byte is an isline node
}
struct ProofIter {
bytes[] proof;
uint256 offset;
}
struct ItemsIter {
Item[] items;
uint256 offset;
}
struct Item {
bytes key;
bytes value;
}
enum ValueMatch {MatchesLeaf, MatchesBranch, NotOmitted, NotFound, IsChild}
enum Step {Descend, UnwindStack}
function verify(bytes32 root,
bytes[] memory proof,
bytes[] memory keys,
bytes[] memory values) internal pure returns (bool) {
require(proof.length > 0, "no proof");
require(keys.length > 0, "no keys");
require(keys.length == values.length, "invalid pair");
Item[] memory items = new Item[](keys.length);
for (uint256 i = 0; i < keys.length; i++) {
items[i] = Item({key: keys[i], value: values[i]});
}
return verify_proof(root, proof, items);
}
function verify_proof(bytes32 root,
bytes[] memory proof,
Item[] memory items) internal pure returns (bool) {
require(proof.length > 0, "no proof");
require(items.length > 0, "no item");
//TODO:: OPT
uint256 maxDepth = proof.length;
StackEntry[] memory stack = new StackEntry[](maxDepth);
uint256 stackLen = 0;
bytes memory rootNode = proof[0];
StackEntry memory lastEntry = decodeNode(rootNode, hex"", false);
ProofIter memory proofIter = ProofIter({proof: proof, offset: 1});
ItemsIter memory itemsIter = ItemsIter({items: items, offset: 0});
while (true) {
Step step;
bytes memory childPrefix;
(step, childPrefix) = advanceItem(lastEntry, itemsIter);
if (step == Step.Descend) {
StackEntry memory nextEntry = advanceChildIndex(lastEntry,
childPrefix,
proofIter);
stack[stackLen] = lastEntry;
stackLen++;
lastEntry = nextEntry;
} else if (step == Step.UnwindStack) {
bytes memory childRef;
{
bool isInline = lastEntry.isInline;
bytes memory nodeData = encodeNode(lastEntry);
if (isInline) {
require(nodeData.length <= 32,
"invalid child reference");
childRef = nodeData;
} else {
childRef = Memory.toBytes(nodeData.hash());
}
}
{
if (stackLen > 0) {
lastEntry = stack[stackLen - 1];
stackLen--;
lastEntry.children[lastEntry.childIndex]
.data = childRef;
} else {
require(proofIter.offset == proofIter.proof.length,
"exraneous proof");
require(childRef.length == 32,
"root hash length should be 32");
bytes32 computedRoot = abi.decode(childRef, (bytes32));
if (computedRoot != root) {
return false;
}
break;
}
}
}
}
return true;
}
function advanceChildIndex(StackEntry memory entry,
bytes memory childPrefix,
ProofIter memory proofIter) internal pure returns (StackEntry memory) {
if (entry.kind == NODEKIND_NOEXT_BRANCH_NOVALUE ||
entry.kind == NODEKIND_NOEXT_BRANCH_WITHVALUE) {
require(childPrefix.length > 0, "this is a branch");
entry.childIndex = uint8(childPrefix[childPrefix.length - 1]);
Node.NodeHandle memory child = entry.children[entry.childIndex];
return makeChildEntry(proofIter, child, childPrefix);
} else {
revert("cannot have children");
}
}
function makeChildEntry(ProofIter memory proofIter,
Node.NodeHandle memory child,
bytes memory prefix) internal pure returns (StackEntry memory) {
if (child.isInline) {
if (child.data.length == 0) {
require(proofIter.offset < proofIter.proof.length,
"incomplete proof");
bytes memory nodeData = proofIter.proof[proofIter.offset];
proofIter.offset++;
return decodeNode(nodeData, prefix, false);
} else {
return decodeNode(child.data, prefix, true);
}
} else {
require(child.data.length == 32, "invalid child reference");
revert("extraneous hash reference");
}
}
function advanceItem(StackEntry memory entry, ItemsIter memory itemsIter)
internal
pure
returns (Step, bytes memory childPrefix)
{
while (itemsIter.offset < itemsIter.items.length) {
Item memory item = itemsIter.items[itemsIter.offset];
bytes memory k = Nibble.keyToNibbles(item.key);
bytes memory v = item.value;
if (startsWith(k, entry.prefix)) {
ValueMatch vm;
(vm, childPrefix) = matchKeyToNode(k,
entry.prefix.length,
entry);
if (ValueMatch.MatchesLeaf == vm) {
if (v.length == 0) {
revert("value mismatch");
}
entry.value = v;
} else if (ValueMatch.MatchesBranch == vm) {
entry.value = v;
} else if (ValueMatch.NotFound == vm) {
if (v.length > 0) {
revert("value mismatch");
}
} else if (ValueMatch.NotOmitted == vm) {
revert("extraneouts value");
} else if (ValueMatch.IsChild == vm) {
return (Step.Descend, childPrefix);
}
itemsIter.offset++;
continue;
}
return (Step.UnwindStack, childPrefix);
}
return (Step.UnwindStack, childPrefix);
}
function matchKeyToNode(bytes memory k,
uint256 prefixLen,
StackEntry memory entry) internal pure returns (ValueMatch vm, bytes memory childPrefix) {
uint256 prefixPlufPartialLen = prefixLen + entry.key.length;
if (entry.kind == NODEKIND_NOEXT_LEAF) {
if (contains(k, entry.key, prefixLen) &&
k.length == prefixPlufPartialLen) {
if (entry.value.length == 0) {
return (ValueMatch.MatchesLeaf, childPrefix);
} else {
return (ValueMatch.NotOmitted, childPrefix);
}
} else {
return (ValueMatch.NotFound, childPrefix);
}
} else if (entry.kind == NODEKIND_NOEXT_BRANCH_NOVALUE ||
entry.kind == NODEKIND_NOEXT_BRANCH_WITHVALUE) {
if (contains(k, entry.key, prefixLen)) {
if (prefixPlufPartialLen == k.length) {
if (entry.value.length == 0) {
return (ValueMatch.MatchesBranch, childPrefix);
} else {
return (ValueMatch.NotOmitted, childPrefix);
}
} else {
uint8 index = uint8(k[prefixPlufPartialLen]);
if (entry.children[index].exist) {
childPrefix = k.substr(0, prefixPlufPartialLen + 1);
return (ValueMatch.IsChild, childPrefix);
} else {
return (ValueMatch.NotFound, childPrefix);
}
}
} else {
return (ValueMatch.NotFound, childPrefix);
}
} else {
revert("not support node type");
}
}
function contains(bytes memory a,
bytes memory b,
uint256 offset) internal pure returns (bool) {
if (a.length < b.length + offset) {
return false;
}
for (uint256 i = 0; i < b.length; i++) {
if (a[i + offset] != b[i]) {
return false;
}
}
return true;
}
function startsWith(bytes memory a, bytes memory b)
internal
pure
returns (bool)
{
if (a.length < b.length) {
return false;
}
for (uint256 i = 0; i < b.length; i++) {
if (a[i] != b[i]) {
return false;
}
}
return true;
}
function encodeNode(StackEntry memory entry)
internal
pure
returns (bytes memory)
{
if (entry.kind == NODEKIND_NOEXT_LEAF) {
Node.Leaf memory l = Node.Leaf({
key: entry.key,
value: entry.value
});
return Node.encodeLeaf(l);
} else if (entry.kind == NODEKIND_NOEXT_BRANCH_NOVALUE ||
entry.kind == NODEKIND_NOEXT_BRANCH_WITHVALUE) {
Node.Branch memory b = Node.Branch({
key: entry.key,
value: entry.value,
children: entry.children
});
return Node.encodeBranch(b);
} else {
revert("not support node kind");
}
}
function decodeNode(bytes memory nodeData,
bytes memory prefix,
bool isInline) internal pure returns (StackEntry memory entry) {
Input.Data memory data = Input.from(nodeData);
uint8 header = data.decodeU8();
uint8 kind = header >> 6;
if (kind == NODEKIND_NOEXT_LEAF) {
//Leaf
Node.Leaf memory leaf = Node.decodeLeaf(data, header);
entry.key = leaf.key;
entry.value = leaf.value;
entry.kind = kind;
entry.prefix = prefix;
entry.isInline = isInline;
} else if (kind == NODEKIND_NOEXT_BRANCH_NOVALUE ||
kind == NODEKIND_NOEXT_BRANCH_WITHVALUE) {
//BRANCH_WITHOUT_MASK_NO_EXT BRANCH_WITH_MASK_NO_EXT
Node.Branch memory branch = Node.decodeBranch(data, header);
entry.key = branch.key;
entry.value = branch.value;
entry.kind = kind;
entry.children = branch.children;
entry.childIndex = 0;
entry.prefix = prefix;
entry.isInline = isInline;
} else {
revert("not support node kind");
}
}
}
| 149,414 | 12,897 |
dd64389391c473264725475fd0c61eadb97850a890d96d718d680d2299447623
| 16,899 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/da/da409731fe5dc39dfef9e3920377450149900c6f_WETHpool.sol
| 4,861 | 15,648 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
interface IToken {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract WETHpool {
using SafeMath for uint256;
IToken public token_BUSD;
address erctoken = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;
uint256 public EGGS_TO_HIRE_1MINERS = 1440000; // 6% APR
uint256 public PERCENTS_DIVIDER = 1000;
uint256 public REFERRAL = 100;
uint256 public TAX = 12; // 6% Tax
uint256 public MARKET_EGGS_DIVISOR = 2; // 50%
uint256 public MARKET_EGGS_DIVISOR_SELL = 1; // 100%
uint256 public MIN_INVEST_LIMIT = 0.1 * 1e18;
uint256 public WALLET_DEPOSIT_LIMIT = 10 * 1e18;
uint256 public COMPOUND_BONUS = 10;
uint256 public COMPOUND_BONUS_MAX_TIMES = 6;
uint256 public COMPOUND_STEP = 12 * 60 * 60;
uint256 public WITHDRAWAL_TAX = 300;
uint256 public COMPOUND_FOR_NO_TAX_WITHDRAWAL = 2; // compound days, for no tax withdrawal.
uint256 public totalStaked;
uint256 public totalDeposits;
uint256 public totalCompound;
uint256 public totalRefBonus;
uint256 public totalWithdrawn;
uint256 public marketEggs;
uint256 PSN = 10000;
uint256 PSNH = 5000;
bool public contractStarted;
uint256 public CUTOFF_STEP = 72 * 60 * 60;
uint256 public WITHDRAW_COOLDOWN = 3 * 60 * 60;
address public owner;
address public dev1;
address public dev2;
address public dev3;
address public dev4;
address public mkt;
struct User {
uint256 initialDeposit;
uint256 userDeposit;
uint256 miners;
uint256 claimedEggs;
uint256 lastHatch;
address referrer;
uint256 referralsCount;
uint256 referralEggRewards;
uint256 totalWithdrawn;
uint256 dailyCompoundBonus;
uint256 lastWithdrawTime;
}
mapping(address => User) public users;
constructor(address _dev1, address _dev2, address _dev3, address _dev4, address _mkt) {
require(!isContract(_dev1) && !isContract(_dev2) && !isContract(_dev3) && !isContract(_dev4) && !isContract(_mkt));
owner = msg.sender;
dev1 = _dev1;
dev2 = _dev2;
dev3 = _dev3;
dev4 = _dev4;
mkt = _mkt;
token_BUSD = IToken(erctoken);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function hatchEggs(bool isCompound) public {
User storage user = users[msg.sender];
require(contractStarted, "Contract not yet Started.");
uint256 eggsUsed = getMyEggs();
uint256 eggsForCompound = eggsUsed;
if(isCompound) {
uint256 dailyCompoundBonus = getDailyCompoundBonus(msg.sender, eggsForCompound);
eggsForCompound = eggsForCompound.add(dailyCompoundBonus);
uint256 eggsUsedValue = calculateEggSell(eggsForCompound);
user.userDeposit = user.userDeposit.add(eggsUsedValue);
totalCompound = totalCompound.add(eggsUsedValue);
}
if(block.timestamp.sub(user.lastHatch) >= COMPOUND_STEP) {
if(user.dailyCompoundBonus < COMPOUND_BONUS_MAX_TIMES) {
user.dailyCompoundBonus = user.dailyCompoundBonus.add(1);
}
}
user.miners = user.miners.add(eggsForCompound.div(EGGS_TO_HIRE_1MINERS));
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(eggsUsed.div(MARKET_EGGS_DIVISOR));
}
function sellEggs() public{
require(contractStarted);
User storage user = users[msg.sender];
uint256 hasEggs = getMyEggs();
uint256 eggValue = calculateEggSell(hasEggs);
if(user.dailyCompoundBonus < COMPOUND_FOR_NO_TAX_WITHDRAWAL){
//daily compound bonus count will not reset and eggValue will be deducted with 60% feedback tax.
eggValue = eggValue.sub(eggValue.mul(WITHDRAWAL_TAX).div(PERCENTS_DIVIDER));
}else{
//set daily compound bonus count to 0 and eggValue will remain without deductions
user.dailyCompoundBonus = 0;
}
user.lastWithdrawTime = block.timestamp;
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(hasEggs.div(MARKET_EGGS_DIVISOR_SELL));
if(getBalance() < eggValue) {
eggValue = getBalance();
}
uint256 eggsPayout = eggValue.sub(payFees(eggValue));
token_BUSD.transfer(msg.sender, eggsPayout);
user.totalWithdrawn = user.totalWithdrawn.add(eggsPayout);
totalWithdrawn = totalWithdrawn.add(eggsPayout);
}
function buyEggs(address ref, uint256 amount) public{
require(contractStarted);
User storage user = users[msg.sender];
require(amount >= MIN_INVEST_LIMIT, "Mininum investment not met.");
require(user.initialDeposit.add(amount) <= WALLET_DEPOSIT_LIMIT, "Max deposit limit reached.");
token_BUSD.transferFrom(address(msg.sender), address(this), amount);
uint256 eggsBought = calculateEggBuy(amount, getBalance().sub(amount));
user.userDeposit = user.userDeposit.add(amount);
user.initialDeposit = user.initialDeposit.add(amount);
user.claimedEggs = user.claimedEggs.add(eggsBought);
if (user.referrer == address(0)) {
if (ref != msg.sender) {
user.referrer = ref;
}
address upline1 = user.referrer;
if (upline1 != address(0)) {
users[upline1].referralsCount = users[upline1].referralsCount.add(1);
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
if (upline != address(0)) {
uint256 refRewards = amount.mul(REFERRAL).div(PERCENTS_DIVIDER);
token_BUSD.transfer(upline, refRewards);
users[upline].referralEggRewards = users[upline].referralEggRewards.add(refRewards);
totalRefBonus = totalRefBonus.add(refRewards);
}
}
uint256 eggsPayout = payFees(amount);
totalStaked = totalStaked.add(amount.sub(eggsPayout));
totalDeposits = totalDeposits.add(1);
hatchEggs(false);
}
function payFees(uint256 eggValue) internal returns(uint256){
uint256 tax = eggValue.mul(TAX).div(PERCENTS_DIVIDER);
token_BUSD.transfer(dev1, tax);
token_BUSD.transfer(dev2, tax);
token_BUSD.transfer(dev3, tax);
token_BUSD.transfer(dev4, tax);
token_BUSD.transfer(mkt, tax);
return tax.mul(5);
}
function getDailyCompoundBonus(address _adr, uint256 amount) public view returns(uint256){
if(users[_adr].dailyCompoundBonus == 0) {
return 0;
} else {
uint256 totalBonus = users[_adr].dailyCompoundBonus.mul(COMPOUND_BONUS);
uint256 result = amount.mul(totalBonus).div(PERCENTS_DIVIDER);
return result;
}
}
function getUserInfo(address _adr) public view returns(uint256 _initialDeposit, uint256 _userDeposit, uint256 _miners,
uint256 _claimedEggs, uint256 _lastHatch, address _referrer, uint256 _referrals,
uint256 _totalWithdrawn, uint256 _referralEggRewards, uint256 _dailyCompoundBonus, uint256 _lastWithdrawTime) {
_initialDeposit = users[_adr].initialDeposit;
_userDeposit = users[_adr].userDeposit;
_miners = users[_adr].miners;
_claimedEggs = users[_adr].claimedEggs;
_lastHatch = users[_adr].lastHatch;
_referrer = users[_adr].referrer;
_referrals = users[_adr].referralsCount;
_totalWithdrawn = users[_adr].totalWithdrawn;
_referralEggRewards = users[_adr].referralEggRewards;
_dailyCompoundBonus = users[_adr].dailyCompoundBonus;
_lastWithdrawTime = users[_adr].lastWithdrawTime;
}
function initialize(uint256 amount) public{
if (!contractStarted) {
if (msg.sender == owner) {
require(marketEggs == 0);
contractStarted = true;
marketEggs = 86400000000;
buyEggs(msg.sender, amount);
} else revert("Contract not yet started.");
}
}
function getBalance() public view returns (uint256) {
return token_BUSD.balanceOf(address(this));
}
function getTimeStamp() public view returns (uint256) {
return block.timestamp;
}
function getAvailableEarnings(address _adr) public view returns(uint256) {
uint256 userEggs = users[_adr].claimedEggs.add(getEggsSinceLastHatch(_adr));
return calculateEggSell(userEggs);
}
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
return SafeMath.div(SafeMath.mul(PSN, bs), SafeMath.add(PSNH, SafeMath.div(SafeMath.add(SafeMath.mul(PSN, rs), SafeMath.mul(PSNH, rt)), rt)));
}
function calculateEggSell(uint256 eggs) public view returns(uint256){
return calculateTrade(eggs, marketEggs, getBalance());
}
function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
return calculateTrade(eth, contractBalance, marketEggs);
}
function calculateEggBuySimple(uint256 eth) public view returns(uint256){
return calculateEggBuy(eth, getBalance());
}
function getEggsYield(uint256 amount) public view returns(uint256,uint256) {
uint256 eggsAmount = calculateEggBuy(amount , getBalance().add(amount).sub(amount));
uint256 miners = eggsAmount.div(EGGS_TO_HIRE_1MINERS);
uint256 day = 1 days;
uint256 eggsPerDay = day.mul(miners);
uint256 earningsPerDay = calculateEggSellForYield(eggsPerDay, amount);
return(miners, earningsPerDay);
}
function calculateEggSellForYield(uint256 eggs,uint256 amount) public view returns(uint256){
return calculateTrade(eggs,marketEggs, getBalance().add(amount));
}
function getSiteInfo() public view returns (uint256 _totalStaked, uint256 _totalDeposits, uint256 _totalCompound, uint256 _totalRefBonus) {
return (totalStaked, totalDeposits, totalCompound, totalRefBonus);
}
function getMyMiners() public view returns(uint256){
return users[msg.sender].miners;
}
function getMyEggs() public view returns(uint256){
return users[msg.sender].claimedEggs.add(getEggsSinceLastHatch(msg.sender));
}
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsSinceLastHatch = block.timestamp.sub(users[adr].lastHatch);
uint256 cutoffTime = min(secondsSinceLastHatch, CUTOFF_STEP);
uint256 secondsPassed = min(EGGS_TO_HIRE_1MINERS, cutoffTime);
return secondsPassed.mul(users[adr].miners);
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
}
function CHANGE_OWNERSHIP(address value) external {
require(msg.sender == owner, "Admin use only.");
owner = value;
}
function CHANGE_DEV1(address value) external {
require(msg.sender == dev1, "Admin use only.");
dev1 = value;
}
function CHANGE_DEV2(address value) external {
require(msg.sender == dev2, "Admin use only.");
dev2 = value;
}
function CHANGE_DEV3(address value) external {
require(msg.sender == dev3, "Admin use only.");
dev3 = value;
}
function CHANGE_MKT_WALLET(address value) external {
require(msg.sender == mkt, "Admin use only.");
mkt = value;
}
// 2592000 - 3%, 2160000 - 4%, 1728000 - 5%, 1440000 - 6%, 1200000 - 7%, 1080000 - 8%
// 959000 - 9%, 864000 - 10%, 720000 - 12%, 575424 - 15%, 540000 - 16%, 479520 - 18%
function PRC_EGGS_TO_HIRE_1MINERS(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 479520 && value <= 2592000);
EGGS_TO_HIRE_1MINERS = value;
}
function PRC_TAX(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 30);
TAX = value;
}
function PRC_REFERRAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 100);
REFERRAL = value;
}
function PRC_MARKET_EGGS_DIVISOR(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 50);
MARKET_EGGS_DIVISOR = value;
}
function SET_WITHDRAWAL_TAX(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 400);
WITHDRAWAL_TAX = value;
}
function SET_COMPOUND_FOR_NO_TAX_WITHDRAWAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
COMPOUND_FOR_NO_TAX_WITHDRAWAL = value;
}
function BONUS_DAILY_COMPOUND(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 900);
COMPOUND_BONUS = value;
}
function BONUS_DAILY_COMPOUND_BONUS_MAX_TIMES(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 30);
COMPOUND_BONUS_MAX_TIMES = value;
}
function BONUS_COMPOUND_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
COMPOUND_STEP = value * 60 * 60;
}
function SET_MIN_INVEST_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
MIN_INVEST_LIMIT = value * 1e18;
}
function SET_CUTOFF_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only");
CUTOFF_STEP = value * 60 * 60;
}
function SET_WITHDRAW_COOLDOWN(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value <= 24);
WITHDRAW_COOLDOWN = value * 60 * 60;
}
function SET_WALLET_DEPOSIT_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value >= 30);
WALLET_DEPOSIT_LIMIT = value * 1e18;
}
}
| 38,431 | 12,898 |
1fb2c468fcbab85c2e9dd7fc445326e971e9de5cddee5836f06710aca3828e7d
| 18,020 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/29/29aa5b3075ce026fc7d218b91c1c45c370cfb4f7_Distributor.sol
| 3,975 | 15,701 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 101,524 | 12,899 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.