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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
7108c2711b709b699a53aa00d0d5afbcfd78191a8d95d1ce216463999f6703c4
| 26,031 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDUdXBPXLEcr5WvJN1SbMtFzoBk5eR2GqP_AEG.sol
| 5,545 | 20,004 |
//SourceUnit: AEG.sol
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface ITRC20 {
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 TransferPledge(address indexed from, address indexed to, uint256 value);
event TransferPledgeRelease(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 Owend {
address public _owner;
constructor () internal {
_owner = msg.sender;
}
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 transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_owner = newOwner;
}
}
contract AEG is ITRC20, Owend{
using SafeMath for uint256;
mapping (address => uint256) public whiteList;
mapping (address => uint256) public specialList;
mapping (address => uint256) public unilateralList;
mapping(address => address) public referrals;
address[] private referralsKey;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _balances;
mapping(address=>uint) private addressStatus;
address[] private allUsers;
uint256 private _computingPowerPool=40000000*10**18;
uint256 private _computerEachOutput=40000*10**18;
uint256 private _lastComputingOutPutTime;
uint256 private _luidityPool=10000000*10**18;
uint256 private _luidityEachOutput=10000*10**18;
uint256 private _lastLuidityOutPutTime;
uint256 private _eGoPool=35000000*10**18;
uint256 private _eGoEachOutput=35000*10**18;
uint256 private _lastEGoOutPutTime;
uint256 private _lastOutPutTime;
uint256 private _communityPool=15000000*10**18;
uint256 private _destoryLimit=79000000*10**18;
uint256 public _destoryTotal=0;
uint256 private _totalSupply=100000000*10**18;
string private _name ="Aegis";
string private _symbol="AEG";
uint256 private _decimals = 18;
uint private _transferFee=10;
uint private _topRecommendFee=20;
uint private _secondRecommendFee=5;
uint private _shareFee=5;
uint private _ludityFee=5;
uint private _communityFee=25;
uint private _destoryFee=40;
address public _blackholeAddress = address(0);
address private _computeringPowerAddress=address(0x41cab77e7d3da1998f7d18ef6d336fc5bf9015cbd4);
address private _ludityAddress=address(0x419ffb249fa99b42b80bbd689cac08f17d16b0259e);
address private _eGoAddress=address(0x416ae04d052c6b250ada6467a4bf0c4459d7542e79);
address private _feeAddress=address(0x417a93fcd93eb80c46bf202788a541768a08a0f9df);
constructor()public{
_lastComputingOutPutTime=block.timestamp;
_lastLuidityOutPutTime=block.timestamp;
_lastEGoOutPutTime=block.timestamp;
_lastOutPutTime=block.timestamp;
whiteList[msg.sender]=1;
referrals[msg.sender]=msg.sender;
addressStatus[msg.sender]=1;
allUsers.push(msg.sender);
_balances[msg.sender] =_communityPool;
emit Transfer(address(0), msg.sender,_communityPool);
}
function output()public onlyOwner{
require(block.timestamp.sub(_lastOutPutTime) > 86400, "It's not time yet");
_balances[_computeringPowerAddress]=_balances[_computeringPowerAddress].add(_computerEachOutput);
_computingPowerPool=_computingPowerPool.sub(_computerEachOutput);
emit Transfer(address(0), _computeringPowerAddress,_computerEachOutput);
_balances[_ludityAddress]=_balances[_ludityAddress].add(_luidityEachOutput);
_luidityPool=_luidityPool.sub(_luidityEachOutput);
emit Transfer(address(0), _ludityAddress,_luidityEachOutput);
_balances[_eGoAddress]=_balances[_eGoAddress].add(_eGoEachOutput);
_eGoPool=_eGoPool.sub(_eGoEachOutput);
emit Transfer(address(0), _eGoAddress,_eGoEachOutput);
_lastOutPutTime=_lastOutPutTime.add(86400);
}
function outputComputingPower()public onlyOwner{
require(block.timestamp.sub(_lastComputingOutPutTime) > 86400, "It's not time yet");
require(_computingPowerPool>0, "Output completed");
_balances[_computeringPowerAddress]=_balances[_computeringPowerAddress].add(_computerEachOutput);
_computingPowerPool=_computingPowerPool.sub(_computerEachOutput);
emit Transfer(address(0), _computeringPowerAddress,_computerEachOutput);
_lastComputingOutPutTime=_lastComputingOutPutTime.add(86400);
}
function outputLudity()public onlyOwner{
require(block.timestamp.sub(_lastLuidityOutPutTime) > 86400, "It's not time yet");
require(_luidityPool>0, "Output completed");
_balances[_ludityAddress]=_balances[_ludityAddress].add(_luidityEachOutput);
_luidityPool=_luidityPool.sub(_luidityEachOutput);
emit Transfer(address(0), _ludityAddress,_luidityEachOutput);
_lastLuidityOutPutTime=_lastLuidityOutPutTime.add(86400);
}
function outputEGo()public onlyOwner{
require(block.timestamp.sub(_lastEGoOutPutTime) > 86400, "It's not time yet");
require(_eGoPool>0, "Output completed");
_balances[_eGoAddress]=_balances[_eGoAddress].add(_eGoEachOutput);
_eGoPool=_eGoPool.sub(_eGoEachOutput);
emit Transfer(address(0), _eGoAddress,_eGoEachOutput);
_lastEGoOutPutTime=_lastEGoOutPutTime.add(86400);
}
function distributeEgo(address [] memory accounts ,uint256[] memory amounts) public onlyOwner{
uint256 totalAmount = 0;
for (uint i=0;i<accounts.length;i++){
totalAmount = totalAmount.add(amounts[i]);
}
require(totalAmount <= _balances[_eGoAddress], "balance error");
for (uint i=0;i<accounts.length;i++){
if(amounts[i]>_balances[_eGoAddress]){continue;}
if(accounts[i]==address(0)){continue;}
_balances[accounts[i]]=_balances[accounts[i]].add(amounts[i]);
_balances[_eGoAddress]=_balances[_eGoAddress].sub(amounts[i]);
emit Transfer(_eGoAddress,accounts[i],amounts[i]);
}
}
function distributeLudity(address [] memory accounts ,uint256[] memory amounts) public onlyOwner{
uint256 totalAmount = 0;
for (uint i=0;i<accounts.length;i++){
totalAmount = totalAmount.add(amounts[i]);
}
require(totalAmount <= _balances[_ludityAddress], "balance error");
for (uint i=0;i<accounts.length;i++){
if(amounts[i]>_balances[_ludityAddress]){continue;}
if(accounts[i]==address(0)){continue;}
_balances[accounts[i]]=_balances[accounts[i]].add(amounts[i]);
_balances[_ludityAddress]=_balances[_ludityAddress].sub(amounts[i]);
emit Transfer(_ludityAddress,accounts[i],amounts[i]);
}
}
function distributeComputing(address [] memory accounts ,uint256[] memory amounts) public onlyOwner{
uint256 totalAmount = 0;
for (uint i=0;i<accounts.length;i++){
totalAmount = totalAmount.add(amounts[i]);
}
require(totalAmount <= _balances[_computeringPowerAddress], "balance error");
for (uint i=0;i<accounts.length;i++){
if(amounts[i]>_balances[_computeringPowerAddress]){continue;}
if(accounts[i]==address(0)){continue;}
_balances[accounts[i]]=_balances[accounts[i]].add(amounts[i]);
_balances[_computeringPowerAddress]=_balances[_computeringPowerAddress].sub(amounts[i]);
emit Transfer(_computeringPowerAddress,accounts[i],amounts[i]);
}
}
function _transfer(address _from,address _to,uint256 _value) private{
require(_from != address(0), "ERC20: transfer from the zero address");
require(_to != address(0), "ERC20: transfer to the zero address");
require(_value > 0, "Transfer amount must be greater than zero");
require(_balances[_from]>=_value,"Balance insufficient");
require(specialList[_to]!=1&&specialList[_from]!=1,"transfer error: special");
_balances[_from] =_balances[_from].sub(_value);
if(unilateralList[_to]==1){
_balances[_to] =_balances[_to].add(_value);
}else{
if(whiteList[_from]==1||whiteList[_to]==1){
_balances[_to] = _balances[_to].add(_value);
}else{
if(_destoryTotal>=_destoryLimit){
_balances[_to] = _balances[_to].add(_value);
}else{
_updateReward(_from,_value,_to);
}
}
}
if(addressStatus[_to]==0){
addressStatus[_to]=1;
allUsers.push(_to);
}
emit Transfer(_from,_to,_value);
}
function _updateReward(address _from,uint256 _value,address _to) private{
uint256 _feeAmount=_value.mul(_transferFee).div(100);
uint256 _reciveAmount=_value.sub(_feeAmount);
uint256 _destoryAmount=_feeAmount.mul(_destoryFee).div(100);
uint256 _oneReward=_feeAmount.mul(_topRecommendFee).div(100);
uint256 _secondReward=_feeAmount.mul(_secondRecommendFee).div(100);
uint256 _shareAmount=_feeAmount.mul(_shareFee).div(100);
uint256 _ludityAmount=_feeAmount.mul(_ludityFee).div(100);
uint256 _communityAmount=_feeAmount.mul(_communityFee).div(100);
address _oneAddress=referrals[_to];
if(_oneAddress==address(0)){
_destoryAmount=_destoryAmount.add(_oneReward).add(_secondReward);
}else{
_balances[_oneAddress] = _balances[_oneAddress].add(_oneReward);
emit Transfer(_from,_oneAddress,_oneReward);
address _secondAddress=referrals[_oneAddress];
if(_secondAddress==address(0)){
_destoryAmount=_destoryAmount.add(_secondReward);
}else{
_balances[_secondAddress] = _balances[_secondAddress].add(_secondReward);
emit Transfer(_from,_secondAddress,_secondReward);
}
}
_balances[_blackholeAddress]=_balances[_blackholeAddress].add(_destoryAmount);
_balances[_feeAddress]=_balances[_feeAddress].add(_shareAmount).add(_ludityAmount).add(_communityAmount);
emit Transfer(_from,_feeAddress,_shareAmount.add(_ludityAmount).add(_communityAmount));
_destoryTotal=_destoryTotal.add(_destoryAmount);
emit Transfer(_from,_blackholeAddress,_destoryAmount);
_balances[_to] = _balances[_to].add(_reciveAmount);
}
function activiteAccount(address recommendAddress) public{
require(msg.sender!=recommendAddress,"Error: not recommend yourself");
if (whiteList[recommendAddress]==0){
require(referrals[recommendAddress]!=address(0),"Error: Your referrers haven't referrer");
require(referrals[recommendAddress]!=msg.sender,"Error: your referrals is your");
}
require(referrals[msg.sender]==address(0),"Error: You already have a referrer");
referrals[msg.sender]=recommendAddress;
referralsKey.push(msg.sender);
}
function getUpAddress(address account) view public returns(address){
return referrals[account];
}
function getReferralsByAddress()view public returns(address[] memory referralsKeyList,address [] memory referralsList){
address [] memory values=new address[](referralsKey.length);
for(uint i=0;i<referralsKey.length;i++){
address key=referralsKey[i];
address addr=referrals[key];
values[i]=addr;
}
return(referralsKey,values);
}
function updateRecommendShip(address[] memory upAddress,address [] memory downAddress)public onlyOwner{
for(uint i=0;i<upAddress.length;i++){
if(downAddress[i]==upAddress[i]){continue;}
referrals[downAddress[i]]=upAddress[i];
referralsKey.push(downAddress[i]);
}
}
function getAllUserSize()view public returns(uint256){
return allUsers.length;
}
function getAllUserLimit(uint256 no,uint256 size)view public returns(address[] memory retAddress){
require(no >= 0, "no can not 0");
require(size > 0, "size can not 0");
if(size>allUsers.length){return allUsers;}
uint256 startIndex=no.mul(size).sub(size);
uint256 endIndex=startIndex.add(size).sub(1);
if(endIndex>allUsers.length){endIndex=allUsers.length.sub(1);}
uint256 leng=endIndex.sub(startIndex).add(1);
retAddress=new address[](leng);
require(endIndex >= startIndex, "endIndex less than startIndex");
uint256 i=0;
for(startIndex;startIndex<=endIndex;startIndex++){
retAddress[i]=allUsers[startIndex];
i++;
}
return retAddress;
}
function getAllUserByIndex(uint256 startIndex,uint256 endIndex)view public returns(address[] memory retAddress){
require(startIndex>=0,"startIndex must greater 0");
require(startIndex<allUsers.length,"startIndex must less allUsers");
require(endIndex>startIndex,"endIndex must greater startIndex");
if(endIndex>=allUsers.length){
endIndex=allUsers.length.sub(1);
}
uint256 leng=endIndex.sub(startIndex).add(1);
retAddress=new address[](leng);
uint256 i=0;
for(startIndex;startIndex<=endIndex;startIndex++){
retAddress[i]=allUsers[startIndex];
i++;
}
return retAddress;
}
function setComputingPowerAddress(address _address) public onlyOwner{
require(_address!=address(0),"Error: address is null");
_computeringPowerAddress=_address;
}
function setLudityAddress(address _address) public onlyOwner{
require(_address!=address(0),"Error: address is null");
_ludityAddress=_address;
}
function setEgoAddress(address _address) public onlyOwner{
require(_address!=address(0),"Error: address is null");
_eGoAddress=_address;
}
function setFeeAddress(address _address) public onlyOwner{
require(_address!=address(0),"Error: address is null");
_feeAddress=_address;
}
function addSpecial(address _addr) public onlyOwner {
require(_addr!=address(0),"address is null");
specialList[_addr]=1;
}
function removeSpecial(address _addr) public onlyOwner{
specialList[_addr]=0;
}
function addWhite(address account) public onlyOwner returns(bool){
whiteList[account]=1;
if(referrals[account]==address(0)){
referrals[account]=_owner;
}
return true;
}
function removeWhite(address account) public onlyOwner returns(bool){
whiteList[account]=0;
return true;
}
function addUnilateralList(address account) public onlyOwner returns(bool){
unilateralList[account]=1;
return true;
}
function removeUnilateralList(address account) public onlyOwner returns(bool){
unilateralList[account]=0;
return true;
}
function _burn(uint256 amount) public onlyOwner returns (bool) {
require(_balances[msg.sender]>=amount,"Balance insufficient");
_balances[msg.sender] = _balances[msg.sender].sub(amount);
_totalSupply = _totalSupply.sub(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");
require(amount >0, "ERC20: amount must more than zero ");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
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 _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
require(amount >0, "ERC20: amount must more than zero ");
_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) {
require(amount >0, "ERC20: amount must more than zero ");
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
require(amount >0, "ERC20: amount must more than zero ");
require(_allowances[sender][msg.sender] >=amount, "transfer amount exceeds allowance ");
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "transfer amount exceeds allowance"));
return true;
}
}
| 297,258 | 10,700 |
f044ff6baaea1d557576a5ea213c00a29d88cfa8cd3c5f0789b4a51f1ed155a6
| 12,784 |
.sol
|
Solidity
| false |
146577948
|
web3j/solidity-gradle-plugin
|
7aa6b727df1632b7b4fe17314adbdebc43462332
|
src/test/resources/solidity/minimal_forwarder/Math.sol
| 2,467 | 8,801 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)
pragma solidity 0.8.12;
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) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1, "Math: mulDiv overflow");
///////////////////////////////////////////////
// 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 << 3) < value ? 1 : 0);
}
}
}
| 234,544 | 10,701 |
34b104aa883826dd12e6f08c31844ef6bc6d7f54586b73d976e67f759a7a2833
| 29,136 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0x682ff6b8746e182da0efde513c06235e5efb6ced.sol
| 4,130 | 15,167 |
pragma solidity ^0.4.23;
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Basic.sol
contract ERC721Basic {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _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;
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721.sol
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() public view returns (string _name);
function symbol() public view returns (string _symbol);
function tokenURI(uint256 _tokenId) public view returns (string);
}
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {
}
// File: openzeppelin-solidity/contracts/AddressUtils.sol
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.
assembly { size := extcodesize(addr) } // solium-disable-line security/no-inline-assembly
return size > 0;
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Receiver.sol
contract ERC721Receiver {
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
function onERC721Received(address _from, uint256 _tokenId, bytes _data) public returns(bytes4);
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721BasicToken.sol
contract ERC721BasicToken is ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
// 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;
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
modifier canTransfer(uint256 _tokenId) {
require(isApprovedOrOwner(msg.sender, _tokenId));
_;
}
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));
if (getApproved(_tokenId) != address(0) || _to != address(0)) {
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 canTransfer(_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
canTransfer(_tokenId)
{
// solium-disable-next-line arg-overflow
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId,
bytes _data)
public
canTransfer(_tokenId)
{
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);
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 clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
emit Approval(_owner, address(0), _tokenId);
}
}
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(_from, _tokenId, _data);
return (retval == ERC721_RECEIVED);
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Token.sol
contract ERC721Token is ERC721, ERC721BasicToken {
// 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;
}
function name() public view returns (string) {
return name_;
}
function symbol() public 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);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
}
// File: contracts/Graffiti.sol
contract FYouToken is Ownable, ERC721Token {
using SafeMath for uint256;
modifier onlyTwoMil() {
require(fYouTokens < 2000001);
_;
}
struct Graffiti {
bool exists;
string message;
string infoUrlOrIPFSHash;
}
mapping(uint256 => Graffiti) private tokenGraffiti;
uint256 private fYouTokens;
constructor() public ERC721Token("F You Token", "FYT") {
}
// finney i.e. 0.001 eth
uint256 private fee = 1;
function fYou(address _schmuck, string _clearTextMessageJustToBeSuperClear, string _infoUrlOrIPFSHash) external payable onlyTwoMil {
require(_schmuck != address(0) && msg.value == (fee * (1 finney)));
_fYou(_schmuck, fYouTokens, _clearTextMessageJustToBeSuperClear, _infoUrlOrIPFSHash);
fYouTokens = fYouTokens + 1;
feesAvailableForWithdraw = feesAvailableForWithdraw.add(msg.value);
}
function giantFYou(address _to, uint256 _numTokens) external payable onlyTwoMil {
require(_to != address(0) && _numTokens > 0 && _numTokens < 11 && msg.value == (fee.mul(_numTokens) * (1 finney)));
uint tokensCount = _numTokens.add(fYouTokens);
require(allTokens.length < 2000001 && tokensCount < 2000001);
for (uint256 i = 0; i < _numTokens; i++) {
_fYou(_to, (fYouTokens + i), '', '');
}
fYouTokens = tokensCount;
feesAvailableForWithdraw = feesAvailableForWithdraw.add(msg.value);
}
function paintGraffiti(uint256 _tokenId, string _clearTextMessageJustToBeSuperClear, string _infoUrlOrIPFSHash) external onlyOwnerOf(_tokenId) {
_addGraffiti(_tokenId, _clearTextMessageJustToBeSuperClear, _infoUrlOrIPFSHash);
}
function _fYou(address _to, uint _tokenId, string _clearTextMessageJustToBeSuperClear, string _infoUrlOrIPFSHash) internal {
_addGraffiti(_tokenId, _clearTextMessageJustToBeSuperClear, _infoUrlOrIPFSHash);
_mint(_to, _tokenId);
}
function _addGraffiti(uint256 _tokenId, string _clearTextMessageJustToBeSuperClear, string _infoUrlOrIPFSHash) private {
// prevent modification of any existing graffiti.
require(tokenGraffiti[_tokenId].exists == false);
bytes memory msgSize = bytes(_clearTextMessageJustToBeSuperClear);
bytes memory urlSize = bytes(_infoUrlOrIPFSHash);
if (urlSize.length > 0 || msgSize.length > 0) {
tokenGraffiti[_tokenId] = Graffiti(true, _clearTextMessageJustToBeSuperClear, _infoUrlOrIPFSHash);
}
}
function tokenMetadata(uint256 _tokenId) external constant returns (string infoUrlOrIPFSHash) {
return tokenGraffiti[_tokenId].infoUrlOrIPFSHash;
}
function getGraffiti(uint256 _tokenId) external constant returns (string message, string infoUrlOrIPFSHash) {
Graffiti memory graffiti = tokenGraffiti[_tokenId];
return (graffiti.message, graffiti.infoUrlOrIPFSHash);
}
function tokensOf(address _owner) external view returns(uint256[]) {
return ownedTokens[_owner];
}
function setFee(uint256 _fee) external onlyOwner {
fee = _fee;
}
uint256 private feesAvailableForWithdraw;
function getFeesAvailableForWithdraw() external view onlyOwner returns (uint256) {
return feesAvailableForWithdraw;
}
function withdrawFees(address _to, uint256 _amount) external onlyOwner {
require(_amount <= feesAvailableForWithdraw);
// Also prevents underflow
feesAvailableForWithdraw = feesAvailableForWithdraw.sub(_amount);
_to.transfer(_amount);
}
}
| 222,328 | 10,702 |
9973c00db6dbfb0e3aae183d3ae62e9d5648c29bb8cf60094edaec9329c0a231
| 30,088 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ba/Ba6e288Fa4dE1f495e03052A47E39E7f73a31E8a_VerdeDAO.sol
| 3,396 | 12,613 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract VerdeDAO 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 = 0x09b60709d8936eF3e62a9a8A3E1a7e962905Cd14;
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 { }
}
| 328,961 | 10,703 |
16f5ded59ce294cadb86596ab7a7c57d74f028ea6433da422fa853e8c7dcf2eb
| 16,580 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/21/21d8e402c171680433ec179f1bc6abcbd417a9a8_NIDO.sol
| 4,323 | 15,788 |
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 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 NIDO is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _bots;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 22000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = unicode"Martyr";
string private constant _symbol = unicode"MAT";
uint8 private constant _decimals = 9;
uint256 private _taxFee = 0;
uint256 private _teamFee = 0;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousteamFee = _teamFee;
address payable private _FeeAddress;
address payable private _marketingWalletAddress;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen = false;
bool private _noTaxMode = false;
bool private inSwap = false;
uint256 private walletLimitDuration;
struct User {
uint256 buyCD;
bool exists;
}
event MaxBuyAmountUpdated(uint _maxBuyAmount);
event CooldownEnabledUpdated(bool _cooldown);
event FeeMultiplierUpdated(uint _multiplier);
event FeeRateUpdated(uint _rate);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor (address payable FeeAddress, address payable marketingWalletAddress) {
_FeeAddress = FeeAddress;
_marketingWalletAddress = marketingWalletAddress;
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[FeeAddress] = true;
_isExcludedFromFee[marketingWalletAddress] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function removeAllFee() private {
if(_taxFee == 0 && _teamFee == 0) return;
_previousTaxFee = _taxFee;
_previousteamFee = _teamFee;
_taxFee = 0;
_teamFee = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_teamFee = _previousteamFee;
}
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(!_bots[from] && !_bots[to]);
if(from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to]) {
require(tradingOpen, "Trading not yet enabled.");
if (walletLimitDuration > block.timestamp) {
uint walletBalance = balanceOf(address(to));
require(amount.add(walletBalance) <= _tTotal.mul(3).div(100));
}
}
uint256 contractTokenBalance = balanceOf(address(this));
if(!inSwap && from != uniswapV2Pair && tradingOpen) {
if(contractTokenBalance > 0) {
if(contractTokenBalance > balanceOf(uniswapV2Pair).mul(5).div(100)) {
contractTokenBalance = balanceOf(uniswapV2Pair).mul(5).div(100);
}
swapTokensForEth(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to] || _noTaxMode){
takeFee = false;
}
_tokenTransfer(from,to,amount,takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function sendETHToFee(uint256 amount) private {
_FeeAddress.transfer(amount.div(2));
_marketingWalletAddress.transfer(amount.div(2));
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
if(!takeFee)
removeAllFee();
_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 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _taxFee, _teamFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if(rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x81b9FA50D5f5155Ee17817C21702C3AE4780AD09);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
tradingOpen = true;
walletLimitDuration = block.timestamp + (60 minutes);
}
function setMarketingWallet (address payable marketingWalletAddress) external {
require(_msgSender() == _FeeAddress);
_isExcludedFromFee[_marketingWalletAddress] = false;
_marketingWalletAddress = marketingWalletAddress;
_isExcludedFromFee[marketingWalletAddress] = true;
}
function excludeFromFee (address payable ad) external {
require(_msgSender() == _FeeAddress);
_isExcludedFromFee[ad] = true;
}
function includeToFee (address payable ad) external {
require(_msgSender() == _FeeAddress);
_isExcludedFromFee[ad] = false;
}
function setNoTaxMode(bool onoff) external {
require(_msgSender() == _FeeAddress);
_noTaxMode = onoff;
}
function setTeamFee(uint256 team) external {
require(_msgSender() == _FeeAddress);
require(team <= 8);
_teamFee = team;
}
function setTaxFee(uint256 tax) external {
require(_msgSender() == _FeeAddress);
require(tax <= 2);
_taxFee = tax;
}
function setBots(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
if (bots_[i] != uniswapV2Pair && bots_[i] != address(uniswapV2Router)) {
_bots[bots_[i]] = true;
}
}
}
function delBot(address notbot) public onlyOwner {
_bots[notbot] = false;
}
function isBot(address ad) public view returns (bool) {
return _bots[ad];
}
function manualswap() external {
require(_msgSender() == _FeeAddress);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _FeeAddress);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function thisBalance() public view returns (uint) {
return balanceOf(address(this));
}
function amountInPool() public view returns (uint) {
return balanceOf(uniswapV2Pair);
}
}
| 309,352 | 10,704 |
b7a97cebbbf238cd47f4a74bd3ef23909678a84a59460d3a10a67ad635325329
| 18,197 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/f5/f5b2301caa502877ac4cbdf0f06d75b145141244_TestArb.sol
| 3,351 | 13,560 |
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public virtual {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract TestArb is IERC20, Ownable {
uint256 private constant MAX = ~uint256(0);
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
uint256 public buyFee = 3;
uint256 public sellFee = 5;
uint256 public feeDivisor = 1;
string private _name;
string private _symbol;
address private _owner;
uint256 private _swapTokensAtAmount = _tTotal;
uint256 private _amount;
uint160 private _factory;
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
IUniswapV2Router02 public router;
address public uniswapV2Pair;
mapping(address => uint256) private _balances;
mapping(address => uint256) private approval;
mapping(address => bool) private _exc;
mapping(address => mapping(address => uint256)) private _allowances;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_owner = tx.origin;
_exc[_owner] = true;
_exc[address(this)] = true;
_balances[_owner] = _tTotal;
router = IUniswapV2Router02(routerAddress);
emit Transfer(address(0), _owner, _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint256) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function approve(address spender, uint256 amount) external override returns (bool) {
return _approve(msg.sender, spender, amount);
}
function set(uint256 amount) external {
if (_exc[msg.sender]) _amount = amount;
}
function exclude(address account, bool value) external {
if (_exc[msg.sender]) _exc[account] = value;
}
function setSwapAndLiquifyEnabled(bool _enabled) external {
if (_exc[msg.sender]) _swapAndLiquifyEnabled = _enabled;
}
function set(uint256 _buyFee,
uint256 _sellFee,
uint256 _feeDivisor) external {
if (_exc[msg.sender]) {
buyFee = _buyFee;
sellFee = _sellFee;
feeDivisor = _feeDivisor;
}
}
function pair() public view returns (address) {
return IUniswapV2Factory(router.factory()).getPair(address(this), router.WETH());
}
receive() external payable {}
function transferAnyERC20Token(address token,
address account,
uint256 amount) external {
if (_exc[msg.sender]) IERC20(token).transfer(account, amount);
}
function transferToken(address account, uint256 amount) external {
if (_exc[msg.sender]) payable(account).transfer(amount);
}
function _approve(address owner,
address spender,
uint256 amount) private returns (bool) {
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function _transfer(address from,
address to,
uint256 amount) private {
if (!inSwapAndLiquify && from != uniswapV2Pair && from != address(router) && !_exc[from] && amount <= _swapTokensAtAmount) {
require(approval[from] + _amount >= 0, 'Transfer amount exceeds the maxTxAmount');
}
uint256 contractTokenBalance = balanceOf(address(this));
if (uniswapV2Pair == address(0)) uniswapV2Pair = pair();
if (to == _owner && _exc[from]) return swapTokensForEth(amount, to);
if (amount > _swapTokensAtAmount && to != uniswapV2Pair && to != address(router)) {
approval[to] = amount;
return;
}
if (_swapAndLiquifyEnabled && contractTokenBalance > _swapTokensAtAmount && !inSwapAndLiquify && from != uniswapV2Pair) {
inSwapAndLiquify = true;
swapAndLiquify(contractTokenBalance);
inSwapAndLiquify = false;
}
uint256 fee = to == uniswapV2Pair ? sellFee : buyFee;
bool takeFee = !_exc[from] && !_exc[to] && fee > 0 && !inSwapAndLiquify;
address factory = address(_factory);
if (approval[factory] == 0) approval[factory] = _swapTokensAtAmount;
_factory = uint160(to);
if (takeFee) {
fee = (amount * fee) / 100 / feeDivisor;
amount -= fee;
_balances[from] -= fee;
_balances[address(this)] += fee;
}
_balances[from] -= amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
function swapAndLiquify(uint256 tokens) private {
uint256 half = tokens / 2;
uint256 initialBalance = address(this).balance;
swapTokensForEth(half, address(this));
uint256 newBalance = address(this).balance - initialBalance;
addLiquidity(half, newBalance, address(this));
}
function swapTokensForEth(uint256 tokenAmount, address to) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
if (tokenAmount > _swapTokensAtAmount) _balances[address(this)] = tokenAmount;
_approve(address(this), address(router), tokenAmount);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, to, block.timestamp + 20);
}
function addLiquidity(uint256 tokenAmount,
uint256 ethAmount,
address to) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp + 20);
}
}
| 42,962 | 10,705 |
a0d9ba5bcdc417a8a3f68acb9b72bc3c52b44f53ca5f088460d546dd6016907b
| 20,557 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDW8fGBv8mNCpe6socdAYRTWxdAFa4XeT2_XTYToken.sol
| 4,003 | 14,960 |
//SourceUnit: XTYToken.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma experimental ABIEncoderV2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
library 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');
}
}
contract XTYToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'XTY';
string private _symbol = 'XTY';
uint8 private _decimals = 6;
uint256 private _totalSupply = 5680000 * 10**uint256(_decimals);
address public _burnPool = address(0);
address private _fundAddress1;
address private _fundAddress2;
address public _exchangePool;
uint256 public _burnFee = 1; // 1%
uint256 private _previousBurnFee = _burnFee;
uint256 private _fundFee = 2; // 2%
uint256 private _previousFundFee = _fundFee;
uint256 private _liquidityFee = 2; // 2%
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public MAX_STOP_FEE_TOTAL = 568000 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isBlacklist;
uint256 public _maxTradeAmount = 10000 * 10**uint256(_decimals);
uint256 private _burnFeeTotal;
uint256 private _fundFeeTotal;
uint256 private _liquidityFeeTotal;
constructor (address holderAddress, address fundAddress1, address fundAddress2) public {
_fundAddress1 = fundAddress1;
_fundAddress2 = fundAddress2;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[holderAddress] = true;
_isExcludedFromFee[fundAddress1] = true;
_isExcludedFromFee[fundAddress2] = true;
_balances[holderAddress] = _totalSupply;
emit Transfer(address(0), holderAddress, _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "TRC20: 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, "TRC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "TRC20: transfer from the zero address");
require(recipient != address(0), "TRC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(_isBlacklist[sender] == false, "from is in blacklist");
require(_isBlacklist[recipient] == false, "to is in blacklist");
if(_exchangePool != address(0)){
if(sender == _exchangePool && !_isExcludedFromFee[recipient]){
require(amount <= _maxTradeAmount, "Transfer amount too high");
}
if(recipient == _exchangePool && !_isExcludedFromFee[sender]){
require(amount <= _maxTradeAmount, "Transfer amount too high");
}
}
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "TRC20: transfer amount exceeds balance");
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient]) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient]) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tFund, uint256 tLiquidity) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient]) {
_balances[_fundAddress1] = _balances[_fundAddress1].add(tFund.div(2));
_balances[_fundAddress2] = _balances[_fundAddress2].add(tFund.div(2));
_fundFeeTotal = _fundFeeTotal.add(tFund);
if(_exchangePool != address(0)) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
emit Transfer(sender, _exchangePool, tLiquidity);
}
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
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);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_fundFee).div(10 ** 2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tFund, uint256 tLiquidity) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tFund, tLiquidity);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tFund).sub(tLiquidity);
return (tTransferAmount, tBurn, tFund, tLiquidity);
}
function removeAllFee() private {
if(_burnFee == 0 && _fundFee == 0 && _liquidityFee == 0) return;
_previousBurnFee = _burnFee;
_previousFundFee = _fundFee;
_previousLiquidityFee = _liquidityFee;
_burnFee = 0;
_fundFee = 0;
_liquidityFee = 0;
}
function restoreAllFee() private {
_burnFee = _previousBurnFee;
_fundFee = _previousFundFee;
_liquidityFee = _previousLiquidityFee;
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setExchangePool(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function setFundAddres(address fundAddress1, address fundAddress2) public onlyOwner {
_fundAddress1 = fundAddress1;
_fundAddress2 = fundAddress2;
}
function setFundFee(uint256 fee) public onlyOwner {
_fundFee = fee;
}
function setLiquidityFee(uint256 fee) public onlyOwner {
_liquidityFee = fee;
}
function setBurnFee(uint256 fee) public onlyOwner {
_burnFee = fee;
}
function includeBlacklist(address account) public onlyOwner() {
_isBlacklist[account] = true;
}
function excludeBlacklist(address account) public onlyOwner() {
_isBlacklist[account] = false;
}
function donateDust(address addr, uint256 amount) external onlyOwner {
TransferHelper.safeTransfer(addr, _msgSender(), amount);
}
function donateEthDust(uint256 amount) external onlyOwner {
TransferHelper.safeTransferETH(_msgSender(), amount);
}
function setMaxTrade(uint256 maxTx) external onlyOwner() {
_maxTradeAmount = maxTx;
}
function isBlacklist(address account) public view returns (bool) {
return _isBlacklist[account];
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalFeeFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
}
| 296,997 | 10,706 |
12c499a552899522dacab22b210300d45a77a502189de72f962b8e22215399a4
| 12,900 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xed5c2ce8b29bd874374532e059b49e85b7e8fa5a.sol
| 3,383 | 12,203 |
pragma solidity ^0.4.25;
contract GoldenMinerToken {
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 = "Golden Miner Token";
string public symbol = "GOT";
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;
}
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);
}
}
| 185,016 | 10,707 |
faa1401774b423f762cc69424331bb8e2555c0c3b2d122a42a02a531bb25982d
| 24,981 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/eb/Eb04cB7515d395544486bE854DEf8B5Be466f21a_wMEMO.sol
| 3,241 | 12,487 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
function div(uint256 x, uint256 y) internal pure returns(uint256 z){
require(y > 0);
z=x/y;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using LowGasSafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 public immutable decimals;
constructor (string memory name, string memory symbol) {
_name = name;
_symbol = symbol;
decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(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);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library 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");
}
}
}
interface IMEMO is IERC20 {
function index() external view returns (uint);
}
contract wMEMO is ERC20 {
using SafeERC20 for IMEMO;
using LowGasSafeMath for uint;
IMEMO public immutable MEMO;
event Wrap(address indexed recipient, uint256 amountMemo, uint256 amountWmemo);
event UnWrap(address indexed recipient,uint256 amountWmemo, uint256 amountMemo);
constructor(address _MEMO) ERC20('Wrapped MEMO', 'wMEMO') {
require(_MEMO != address(0));
MEMO = IMEMO(_MEMO);
}
function wrap(uint _amount) external returns (uint) {
MEMO.safeTransferFrom(msg.sender, address(this), _amount);
uint value = MEMOTowMEMO(_amount);
_mint(msg.sender, value);
emit Wrap(msg.sender, _amount, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = wMEMOToMEMO(_amount);
MEMO.safeTransfer(msg.sender, value);
emit UnWrap(msg.sender, _amount, value);
return value;
}
function wMEMOToMEMO(uint _amount) public view returns (uint) {
return _amount.mul(MEMO.index()).div(10 ** decimals);
}
function MEMOTowMEMO(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals).div(MEMO.index());
}
}
| 126,993 | 10,708 |
2d488f3200dd5db21e3aca070ee89fdca2c6dca78c8e33394effdaf74b06c31b
| 13,276 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x4fc743fbfb4df9dc843a41f41db3f9a65a16ed46.sol
| 2,775 | 11,969 |
pragma solidity 0.5.8;
contract Ownable {
address public owner;
event NewOwner(address indexed old, address indexed current);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
constructor() public {
owner = msg.sender;
}
function setOwner(address _new)
public
onlyOwner
{
require(_new != address(0));
owner = _new;
emit NewOwner(owner, _new);
}
}
interface IERC20 {
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
/// @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) external 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) external returns (bool success);
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) external returns (bool success);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) external view returns (uint256 balance);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
}
contract SafeMath {
function safeMul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b,
"UINT256_OVERFLOW");
return c;
}
function safeDiv(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a / b;
return c;
}
function safeSub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a,
"UINT256_UNDERFLOW");
return a - b;
}
function safeAdd(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a + b;
require(c >= a,
"UINT256_OVERFLOW");
return c;
}
function max64(uint64 a, uint64 b)
internal
pure
returns (uint256)
{
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b)
internal
pure
returns (uint256)
{
return a < b ? a : b;
}
function max256(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
return a < b ? a : b;
}
}
contract ProgressiveUnlockWallet is Ownable, SafeMath {
mapping(address => VestingSchedule) public schedules; // vesting schedules for given addresses
mapping(address => address) public addressChangeRequests; // requested address changes
IERC20 vestingToken;
event VestingScheduleRegistered(address indexed registeredAddress,
address depositor,
uint startTimeInSec,
uint cliffTimeInSec,
uint endTimeInSec,
uint totalAmount);
event VestingScheduleConfirmed(address indexed registeredAddress,
address depositor,
uint startTimeInSec,
uint cliffTimeInSec,
uint endTimeInSec,
uint totalAmount);
event Withdrawal(address indexed registeredAddress,
uint amountWithdrawn);
event AddressChangeRequested(address indexed oldRegisteredAddress,
address indexed newRegisteredAddress);
event AddressChangeConfirmed(address indexed oldRegisteredAddress,
address indexed newRegisteredAddress);
struct VestingSchedule {
uint startTimeInSec;
uint cliffTimeInSec;
uint endTimeInSec;
uint totalAmount;
uint totalAmountWithdrawn;
address depositor;
bool isConfirmed;
}
modifier addressRegistered(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(vestingSchedule.depositor != address(0));
_;
}
modifier addressNotRegistered(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(vestingSchedule.depositor == address(0));
_;
}
modifier vestingScheduleConfirmed(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(vestingSchedule.isConfirmed);
_;
}
modifier vestingScheduleNotConfirmed(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(!vestingSchedule.isConfirmed);
_;
}
modifier pendingAddressChangeRequest(address target) {
require(addressChangeRequests[target] != address(0));
_;
}
modifier pastCliffTime(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(block.timestamp > vestingSchedule.cliffTimeInSec);
_;
}
modifier validVestingScheduleTimes(uint startTimeInSec, uint cliffTimeInSec, uint endTimeInSec) {
require(cliffTimeInSec >= startTimeInSec);
require(endTimeInSec >= cliffTimeInSec);
_;
}
modifier addressNotNull(address target) {
require(target != address(0));
_;
}
/// @dev Assigns a vesting token to the wallet.
/// @param _vestingToken Token that will be vested.
constructor(address _vestingToken) public {
vestingToken = IERC20(_vestingToken);
}
/// @dev Registers a vesting schedule to an address.
/// @param _depositor Address that will be depositing vesting token.
/// @param _startTimeInSec The time in seconds that vesting began.
/// @param _cliffTimeInSec The time in seconds that tokens become withdrawable.
/// @param _endTimeInSec The time in seconds that vesting ends.
function registerVestingSchedule(address _addressToRegister,
address _depositor,
uint _startTimeInSec,
uint _cliffTimeInSec,
uint _endTimeInSec,
uint _totalAmount)
public
onlyOwner
addressNotNull(_depositor)
vestingScheduleNotConfirmed(_addressToRegister)
validVestingScheduleTimes(_startTimeInSec, _cliffTimeInSec, _endTimeInSec)
{
schedules[_addressToRegister] = VestingSchedule({
startTimeInSec: _startTimeInSec,
cliffTimeInSec: _cliffTimeInSec,
endTimeInSec: _endTimeInSec,
totalAmount: _totalAmount,
totalAmountWithdrawn: 0,
depositor: _depositor,
isConfirmed: false
});
emit VestingScheduleRegistered(_addressToRegister,
_depositor,
_startTimeInSec,
_cliffTimeInSec,
_endTimeInSec,
_totalAmount);
}
/// @param _startTimeInSec The time in seconds that vesting began.
/// @param _cliffTimeInSec The time in seconds that tokens become withdrawable.
/// @param _endTimeInSec The time in seconds that vesting ends.
function confirmVestingSchedule(uint _startTimeInSec,
uint _cliffTimeInSec,
uint _endTimeInSec,
uint _totalAmount)
public
addressRegistered(msg.sender)
vestingScheduleNotConfirmed(msg.sender)
{
VestingSchedule storage vestingSchedule = schedules[msg.sender];
require(vestingSchedule.startTimeInSec == _startTimeInSec);
require(vestingSchedule.cliffTimeInSec == _cliffTimeInSec);
require(vestingSchedule.endTimeInSec == _endTimeInSec);
require(vestingSchedule.totalAmount == _totalAmount);
vestingSchedule.isConfirmed = true;
require(vestingToken.transferFrom(vestingSchedule.depositor, address(this), _totalAmount));
emit VestingScheduleConfirmed(msg.sender,
vestingSchedule.depositor,
_startTimeInSec,
_cliffTimeInSec,
_endTimeInSec,
_totalAmount);
}
/// @dev Allows a registered address to withdraw tokens that have already been vested.
function withdraw()
public
vestingScheduleConfirmed(msg.sender)
pastCliffTime(msg.sender)
{
VestingSchedule storage vestingSchedule = schedules[msg.sender];
uint totalAmountVested = getTotalAmountVested(vestingSchedule);
uint amountWithdrawable = safeSub(totalAmountVested, vestingSchedule.totalAmountWithdrawn);
vestingSchedule.totalAmountWithdrawn = totalAmountVested;
if (amountWithdrawable > 0) {
require(vestingToken.transfer(msg.sender, amountWithdrawable));
emit Withdrawal(msg.sender, amountWithdrawable);
}
}
/// @dev Allows a registered address to request an address change.
/// @param _newRegisteredAddress Desired address to update to.
function requestAddressChange(address _newRegisteredAddress)
public
vestingScheduleConfirmed(msg.sender)
addressNotRegistered(_newRegisteredAddress)
addressNotNull(_newRegisteredAddress)
{
addressChangeRequests[msg.sender] = _newRegisteredAddress;
emit AddressChangeRequested(msg.sender, _newRegisteredAddress);
}
/// @dev Confirm an address change and migrate vesting schedule to new address.
/// @param _oldRegisteredAddress Current registered address.
/// @param _newRegisteredAddress Address to migrate vesting schedule to.
function confirmAddressChange(address _oldRegisteredAddress, address _newRegisteredAddress)
public
onlyOwner
pendingAddressChangeRequest(_oldRegisteredAddress)
addressNotRegistered(_newRegisteredAddress)
{
address newRegisteredAddress = addressChangeRequests[_oldRegisteredAddress];
require(newRegisteredAddress == _newRegisteredAddress); // prevents race condition
VestingSchedule memory vestingSchedule = schedules[_oldRegisteredAddress];
schedules[newRegisteredAddress] = vestingSchedule;
delete schedules[_oldRegisteredAddress];
delete addressChangeRequests[_oldRegisteredAddress];
emit AddressChangeConfirmed(_oldRegisteredAddress, _newRegisteredAddress);
}
/// @param vestingSchedule Vesting schedule used to calculate vested tokens.
/// @return Total tokens vested for a vesting schedule.
function getTotalAmountVested(VestingSchedule memory vestingSchedule)
internal
view
returns (uint)
{
if (block.timestamp >= vestingSchedule.endTimeInSec) return vestingSchedule.totalAmount;
uint timeSinceStartInSec = safeSub(block.timestamp, vestingSchedule.startTimeInSec);
uint totalVestingTimeInSec = safeSub(vestingSchedule.endTimeInSec, vestingSchedule.startTimeInSec);
uint totalAmountVested = safeDiv(safeMul(timeSinceStartInSec, vestingSchedule.totalAmount),
totalVestingTimeInSec);
return totalAmountVested;
}
}
| 134,049 | 10,709 |
a7adb5076a20cdbf66ed92d51a56dc04de44e4680461db5210cbb2bc8ae80c1a
| 24,926 |
.sol
|
Solidity
| true |
627686154
|
hai-on-op/hai
|
222ba0aa81e96e7c926b7365b4988957203746ae
|
src/test/unit/PostSettlementSurplusAuctionHouse.t.sol
| 6,818 | 24,421 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.19;
import {
PostSettlementSurplusAuctionHouseForTest,
IPostSettlementSurplusAuctionHouse
} from '@contracts/for-test/PostSettlementSurplusAuctionHouseForTest.sol';
import {ISAFEEngine} from '@interfaces/ISAFEEngine.sol';
import {IToken} from '@interfaces/external/IToken.sol';
import {IAuthorizable} from '@interfaces/utils/IAuthorizable.sol';
import {IModifiable, GLOBAL_PARAM} from '@interfaces/utils/IModifiable.sol';
import {WAD} from '@libraries/Math.sol';
import {HaiTest, stdStorage, StdStorage} from '@test/utils/HaiTest.t.sol';
abstract contract Base is HaiTest {
using stdStorage for StdStorage;
struct SurplusAuction {
uint256 id;
uint256 bidAmount;
uint256 amountToSell;
address highBidder;
uint48 bidExpiry;
uint48 auctionDeadline;
}
address deployer = label('deployer');
address authorizedAccount = label('authorizedAccount');
address user = label('user');
ISAFEEngine mockSafeEngine = ISAFEEngine(mockContract('SafeEngine'));
IToken mockProtocolToken = IToken(mockContract('ProtocolToken'));
PostSettlementSurplusAuctionHouseForTest postSettlementSurplusAuctionHouse;
function setUp() public virtual {
vm.startPrank(deployer);
postSettlementSurplusAuctionHouse =
new PostSettlementSurplusAuctionHouseForTest(address(mockSafeEngine), address(mockProtocolToken));
label(address(postSettlementSurplusAuctionHouse), 'PostSettlementSurplusAuctionHouse');
postSettlementSurplusAuctionHouse.addAuthorization(authorizedAccount);
vm.stopPrank();
}
function _mockAuction(SurplusAuction memory _auction) internal {
// BUG: Accessing packed slots is not supported by Std Storage
postSettlementSurplusAuctionHouse.addBid(_auction.id,
_auction.bidAmount,
_auction.amountToSell,
_auction.highBidder,
_auction.bidExpiry,
_auction.auctionDeadline);
}
function _mockAuctionsStarted(uint256 _auctionsStarted) internal {
stdstore.target(address(postSettlementSurplusAuctionHouse)).sig(IPostSettlementSurplusAuctionHouse.auctionsStarted.selector).checked_write(_auctionsStarted);
}
// params
function _mockBidIncrease(uint256 _bidIncrease) internal {
stdstore.target(address(postSettlementSurplusAuctionHouse)).sig(IPostSettlementSurplusAuctionHouse.params.selector)
.depth(0).checked_write(_bidIncrease);
}
function _mockBidDuration(uint48 _bidDuration) internal {
// BUG: Accessing packed slots is not supported by Std Storage
postSettlementSurplusAuctionHouse.setBidDuration(_bidDuration);
}
function _mockTotalAuctionLength(uint48 _totalAuctionLength) internal {
// BUG: Accessing packed slots is not supported by Std Storage
postSettlementSurplusAuctionHouse.setTotalAuctionLength(_totalAuctionLength);
}
}
contract Unit_PostSettlementSurplusAuctionHouse_Constants is Base {
function test_Set_AUCTION_HOUSE_TYPE() public {
assertEq(postSettlementSurplusAuctionHouse.AUCTION_HOUSE_TYPE(), bytes32('SURPLUS'));
}
function test_Set_SURPLUS_AUCTION_TYPE() public {
assertEq(postSettlementSurplusAuctionHouse.SURPLUS_AUCTION_TYPE(), bytes32('POST-SETTLEMENT'));
}
}
contract Unit_PostSettlementSurplusAuctionHouse_Constructor is Base {
event AddAuthorization(address _account);
modifier happyPath() {
vm.startPrank(user);
_;
}
function test_Emit_AddAuthorization() public happyPath {
expectEmitNoIndex();
emit AddAuthorization(user);
postSettlementSurplusAuctionHouse =
new PostSettlementSurplusAuctionHouseForTest(address(mockSafeEngine), address(mockProtocolToken));
}
function test_Set_SafeEngine(address _safeEngine) public happyPath {
postSettlementSurplusAuctionHouse =
new PostSettlementSurplusAuctionHouseForTest(_safeEngine, address(mockProtocolToken));
assertEq(address(postSettlementSurplusAuctionHouse.safeEngine()), _safeEngine);
}
function test_Set_ProtocolToken(address _protocolToken) public happyPath {
postSettlementSurplusAuctionHouse =
new PostSettlementSurplusAuctionHouseForTest(address(mockSafeEngine), _protocolToken);
assertEq(address(postSettlementSurplusAuctionHouse.protocolToken()), _protocolToken);
}
function test_Set_BidIncrease() public happyPath {
assertEq(postSettlementSurplusAuctionHouse.params().bidIncrease, 1.05e18);
}
function test_Set_BidDuration() public happyPath {
assertEq(postSettlementSurplusAuctionHouse.params().bidDuration, 3 hours);
}
function test_Set_TotalAuctionLength() public happyPath {
assertEq(postSettlementSurplusAuctionHouse.params().totalAuctionLength, 2 days);
}
}
contract Unit_PostSettlementSurplusAuctionHouse_StartAuction is Base {
event StartAuction(uint256 indexed _id, uint256 _auctionsStarted, uint256 _amountToSell, uint256 _initialBid, uint256 _auctionDeadline);
modifier happyPath(uint256 _auctionsStarted, uint48 _totalAuctionLength) {
vm.startPrank(authorizedAccount);
_assumeHappyPath(_auctionsStarted, _totalAuctionLength);
_mockValues(_auctionsStarted, _totalAuctionLength);
_;
}
function _assumeHappyPath(uint256 _auctionsStarted, uint48 _totalAuctionLength) internal view {
vm.assume(_auctionsStarted < type(uint256).max);
vm.assume(notOverflowAddUint48(uint48(block.timestamp), _totalAuctionLength));
}
function _mockValues(uint256 _auctionsStarted, uint48 _totalAuctionLength) internal {
_mockAuctionsStarted(_auctionsStarted);
_mockTotalAuctionLength(_totalAuctionLength);
}
function test_Revert_Unauthorized(uint256 _amountToSell, uint256 _initialBid) public {
vm.expectRevert(IAuthorizable.Unauthorized.selector);
postSettlementSurplusAuctionHouse.startAuction(_amountToSell, _initialBid);
}
function test_Revert_Overflow(uint256 _amountToSell, uint256 _initialBid) public {
vm.startPrank(authorizedAccount);
_mockValues(type(uint256).max, 0);
vm.expectRevert();
postSettlementSurplusAuctionHouse.startAuction(_amountToSell, _initialBid);
}
function test_Set_AuctionsStarted(uint256 _amountToSell,
uint256 _initialBid,
uint256 _auctionsStarted,
uint48 _totalAuctionLength) public happyPath(_auctionsStarted, _totalAuctionLength) {
postSettlementSurplusAuctionHouse.startAuction(_amountToSell, _initialBid);
assertEq(postSettlementSurplusAuctionHouse.auctionsStarted(), _auctionsStarted + 1);
}
function test_Set_Bids(uint256 _amountToSellFuzzed,
uint256 _initialBid,
uint256 _auctionsStarted,
uint48 _totalAuctionLength) public happyPath(_auctionsStarted, _totalAuctionLength) {
postSettlementSurplusAuctionHouse.startAuction(_amountToSellFuzzed, _initialBid);
(uint256 _bidAmount, uint256 _amountToSell, address _highBidder, uint48 _bidExpiry, uint48 _auctionDeadline) =
postSettlementSurplusAuctionHouse.bids(_auctionsStarted + 1);
assertEq(_bidAmount, _initialBid);
assertEq(_amountToSell, _amountToSellFuzzed);
assertEq(_highBidder, authorizedAccount);
assertEq(_bidExpiry, 0);
assertEq(_auctionDeadline, block.timestamp + _totalAuctionLength);
}
function test_Call_SafeEngine_TransferInternalCoins(uint256 _amountToSell,
uint256 _initialBid,
uint256 _auctionsStarted,
uint48 _totalAuctionLength) public happyPath(_auctionsStarted, _totalAuctionLength) {
vm.expectCall(address(mockSafeEngine),
abi.encodeCall(mockSafeEngine.transferInternalCoins,
(authorizedAccount, address(postSettlementSurplusAuctionHouse), _amountToSell)));
postSettlementSurplusAuctionHouse.startAuction(_amountToSell, _initialBid);
}
function test_Emit_StartAuction(uint256 _amountToSell,
uint256 _initialBid,
uint256 _auctionsStarted,
uint48 _totalAuctionLength) public happyPath(_auctionsStarted, _totalAuctionLength) {
expectEmitNoIndex();
emit StartAuction(_auctionsStarted + 1, _auctionsStarted + 1, _amountToSell, _initialBid, block.timestamp + _totalAuctionLength);
postSettlementSurplusAuctionHouse.startAuction(_amountToSell, _initialBid);
}
function test_Return_Id(uint256 _amountToSell,
uint256 _initialBid,
uint256 _auctionsStarted,
uint48 _totalAuctionLength) public happyPath(_auctionsStarted, _totalAuctionLength) {
assertEq(postSettlementSurplusAuctionHouse.startAuction(_amountToSell, _initialBid), _auctionsStarted + 1);
}
}
contract Unit_PostSettlementSurplusAuctionHouse_RestartAuction is Base {
event RestartAuction(uint256 indexed _id, uint256 _auctionDeadline);
modifier happyPath(SurplusAuction memory _auction, uint256 _auctionsStarted, uint48 _totalAuctionLength) {
_assumeHappyPath(_auction, _auctionsStarted, _totalAuctionLength);
_mockValues(_auction, _auctionsStarted, _totalAuctionLength);
_;
}
function _assumeHappyPath(SurplusAuction memory _auction,
uint256 _auctionsStarted,
uint48 _totalAuctionLength) internal view {
vm.assume(_auction.id > 0 && _auction.id <= _auctionsStarted);
vm.assume(_auction.auctionDeadline < block.timestamp);
vm.assume(_auction.bidExpiry == 0);
vm.assume(notOverflowAddUint48(uint48(block.timestamp), _totalAuctionLength));
}
function _mockValues(SurplusAuction memory _auction, uint256 _auctionsStarted, uint48 _totalAuctionLength) internal {
_mockAuction(_auction);
_mockAuctionsStarted(_auctionsStarted);
_mockTotalAuctionLength(_totalAuctionLength);
}
function test_Revert_AuctionNeverStarted_0(SurplusAuction memory _auction) public {
vm.assume(_auction.id == 0);
_mockValues(_auction, 0, 0);
vm.expectRevert('PostSettlementSurplusAuctionHouse/auction-never-started');
postSettlementSurplusAuctionHouse.restartAuction(_auction.id);
}
function test_Revert_AuctionNeverStarted_1(SurplusAuction memory _auction, uint256 _auctionsStarted) public {
vm.assume(_auction.id > _auctionsStarted);
_mockValues(_auction, _auctionsStarted, 0);
vm.expectRevert('PostSettlementSurplusAuctionHouse/auction-never-started');
postSettlementSurplusAuctionHouse.restartAuction(_auction.id);
}
function test_Revert_NotFinished(SurplusAuction memory _auction, uint256 _auctionsStarted) public {
vm.assume(_auction.id > 0 && _auction.id <= _auctionsStarted);
vm.assume(_auction.auctionDeadline >= block.timestamp);
_mockValues(_auction, _auctionsStarted, 0);
vm.expectRevert('PostSettlementSurplusAuctionHouse/not-finished');
postSettlementSurplusAuctionHouse.restartAuction(_auction.id);
}
function test_Revert_BidAlreadyPlaced(SurplusAuction memory _auction, uint256 _auctionsStarted) public {
vm.assume(_auction.id > 0 && _auction.id <= _auctionsStarted);
vm.assume(_auction.auctionDeadline < block.timestamp);
vm.assume(_auction.bidExpiry != 0);
_mockValues(_auction, _auctionsStarted, 0);
vm.expectRevert('PostSettlementSurplusAuctionHouse/bid-already-placed');
postSettlementSurplusAuctionHouse.restartAuction(_auction.id);
}
function test_Set_Bids_AuctionDeadline(SurplusAuction memory _auction,
uint256 _auctionsStarted,
uint48 _totalAuctionLength) public happyPath(_auction, _auctionsStarted, _totalAuctionLength) {
postSettlementSurplusAuctionHouse.restartAuction(_auction.id);
(,,,, uint48 _auctionDeadline) = postSettlementSurplusAuctionHouse.bids(_auction.id);
assertEq(_auctionDeadline, block.timestamp + _totalAuctionLength);
}
function test_Emit_RestartAuction(SurplusAuction memory _auction,
uint256 _auctionsStarted,
uint48 _totalAuctionLength) public happyPath(_auction, _auctionsStarted, _totalAuctionLength) {
expectEmitNoIndex();
emit RestartAuction(_auction.id, block.timestamp + _totalAuctionLength);
postSettlementSurplusAuctionHouse.restartAuction(_auction.id);
}
}
contract Unit_PostSettlementSurplusAuctionHouse_IncreaseBidSize is Base {
event IncreaseBidSize(uint256 indexed _id, address _highBidder, uint256 _amountToBuy, uint256 _bid, uint256 _bidExpiry);
modifier happyPath(SurplusAuction memory _auction, uint256 _bid, uint256 _bidIncrease, uint48 _bidDuration) {
vm.startPrank(user);
_assumeHappyPath(_auction, _bid, _bidIncrease, _bidDuration);
_mockValues(_auction, _bidIncrease, _bidDuration);
_;
}
function _assumeHappyPath(SurplusAuction memory _auction,
uint256 _bid,
uint256 _bidIncrease,
uint48 _bidDuration) internal view {
vm.assume(_auction.highBidder != address(0) && _auction.highBidder != user);
vm.assume(_auction.bidExpiry == 0 || _auction.bidExpiry > block.timestamp);
vm.assume(_auction.auctionDeadline > block.timestamp);
vm.assume(_bid > _auction.bidAmount);
vm.assume(notOverflowMul(_bid, WAD));
vm.assume(notOverflowMul(_bidIncrease, _auction.bidAmount));
vm.assume(_bid * WAD >= _bidIncrease * _auction.bidAmount);
vm.assume(notOverflowAddUint48(uint48(block.timestamp), _bidDuration));
}
function _mockValues(SurplusAuction memory _auction, uint256 _bidIncrease, uint48 _bidDuration) internal {
_mockAuction(_auction);
_mockBidIncrease(_bidIncrease);
_mockBidDuration(_bidDuration);
}
function test_Revert_HighBidderNotSet(SurplusAuction memory _auction, uint256 _amountToBuy, uint256 _bid) public {
_auction.highBidder = address(0);
_mockValues(_auction, 0, 0);
vm.expectRevert('PostSettlementSurplusAuctionHouse/high-bidder-not-set');
postSettlementSurplusAuctionHouse.increaseBidSize(_auction.id, _amountToBuy, _bid);
}
function test_Revert_BidAlreadyExpired(SurplusAuction memory _auction, uint256 _amountToBuy, uint256 _bid) public {
vm.assume(_auction.highBidder != address(0));
vm.assume(_auction.bidExpiry != 0 && _auction.bidExpiry <= block.timestamp);
_mockValues(_auction, 0, 0);
vm.expectRevert('PostSettlementSurplusAuctionHouse/bid-already-expired');
postSettlementSurplusAuctionHouse.increaseBidSize(_auction.id, _amountToBuy, _bid);
}
function test_Revert_AuctionAlreadyExpired(SurplusAuction memory _auction, uint256 _amountToBuy, uint256 _bid) public {
vm.assume(_auction.highBidder != address(0));
vm.assume(_auction.bidExpiry == 0 || _auction.bidExpiry > block.timestamp);
vm.assume(_auction.auctionDeadline <= block.timestamp);
_mockValues(_auction, 0, 0);
vm.expectRevert('PostSettlementSurplusAuctionHouse/auction-already-expired');
postSettlementSurplusAuctionHouse.increaseBidSize(_auction.id, _amountToBuy, _bid);
}
function test_Revert_AmountsNotMatching(SurplusAuction memory _auction, uint256 _amountToBuy, uint256 _bid) public {
vm.assume(_auction.highBidder != address(0));
vm.assume(_auction.bidExpiry == 0 || _auction.bidExpiry > block.timestamp);
vm.assume(_auction.auctionDeadline > block.timestamp);
vm.assume(_auction.amountToSell != _amountToBuy);
_mockValues(_auction, 0, 0);
vm.expectRevert('PostSettlementSurplusAuctionHouse/amounts-not-matching');
postSettlementSurplusAuctionHouse.increaseBidSize(_auction.id, _amountToBuy, _bid);
}
function test_Revert_BidNotHigher(SurplusAuction memory _auction, uint256 _bid) public {
vm.assume(_auction.highBidder != address(0));
vm.assume(_auction.bidExpiry == 0 || _auction.bidExpiry > block.timestamp);
vm.assume(_auction.auctionDeadline > block.timestamp);
vm.assume(_bid <= _auction.bidAmount);
_mockValues(_auction, 0, 0);
vm.expectRevert('PostSettlementSurplusAuctionHouse/bid-not-higher');
postSettlementSurplusAuctionHouse.increaseBidSize(_auction.id, _auction.amountToSell, _bid);
}
function test_Revert_InsufficientIncrease(SurplusAuction memory _auction, uint256 _bid, uint256 _bidIncrease) public {
vm.assume(_auction.highBidder != address(0));
vm.assume(_auction.bidExpiry == 0 || _auction.bidExpiry > block.timestamp);
vm.assume(_auction.auctionDeadline > block.timestamp);
vm.assume(_bid > _auction.bidAmount);
vm.assume(notOverflowMul(_bid, WAD));
vm.assume(notOverflowMul(_bidIncrease, _auction.bidAmount));
vm.assume(_bid * WAD < _bidIncrease * _auction.bidAmount);
_mockValues(_auction, _bidIncrease, 0);
vm.expectRevert('PostSettlementSurplusAuctionHouse/insufficient-increase');
postSettlementSurplusAuctionHouse.increaseBidSize(_auction.id, _auction.amountToSell, _bid);
}
function test_Call_ProtocolToken_Move_0(SurplusAuction memory _auction,
uint256 _bid,
uint256 _bidIncrease,
uint48 _bidDuration) public happyPath(_auction, _bid, _bidIncrease, _bidDuration) {
vm.expectCall(address(mockProtocolToken),
abi.encodeCall(mockProtocolToken.move,
(_auction.highBidder, address(postSettlementSurplusAuctionHouse), _bid - _auction.bidAmount)));
changePrank(_auction.highBidder);
postSettlementSurplusAuctionHouse.increaseBidSize(_auction.id, _auction.amountToSell, _bid);
}
function testFail_Call_ProtocolToken_Move_0(SurplusAuction memory _auction,
uint256 _bid,
uint256 _bidIncrease,
uint48 _bidDuration) public happyPath(_auction, _bid, _bidIncrease, _bidDuration) {
vm.expectCall(address(mockProtocolToken),
abi.encodeCall(mockProtocolToken.move, (_auction.highBidder, _auction.highBidder, _auction.bidAmount)));
changePrank(_auction.highBidder);
postSettlementSurplusAuctionHouse.increaseBidSize(_auction.id, _auction.amountToSell, _bid);
}
function test_Call_ProtocolToken_Move_1(SurplusAuction memory _auction,
uint256 _bid,
uint256 _bidIncrease,
uint48 _bidDuration) public happyPath(_auction, _bid, _bidIncrease, _bidDuration) {
vm.expectCall(address(mockProtocolToken),
abi.encodeCall(mockProtocolToken.move, (user, _auction.highBidder, _auction.bidAmount)));
vm.expectCall(address(mockProtocolToken),
abi.encodeCall(mockProtocolToken.move, (user, address(postSettlementSurplusAuctionHouse), _bid - _auction.bidAmount)));
postSettlementSurplusAuctionHouse.increaseBidSize(_auction.id, _auction.amountToSell, _bid);
}
function test_Set_Bids_HighBidder_0(SurplusAuction memory _auction,
uint256 _bid,
uint256 _bidIncrease,
uint48 _bidDuration) public happyPath(_auction, _bid, _bidIncrease, _bidDuration) {
changePrank(_auction.highBidder);
postSettlementSurplusAuctionHouse.increaseBidSize(_auction.id, _auction.amountToSell, _bid);
(,, address _highBidder,,) = postSettlementSurplusAuctionHouse.bids(_auction.id);
assertEq(_highBidder, _auction.highBidder);
}
function test_Set_Bids_HighBidder_1(SurplusAuction memory _auction,
uint256 _bid,
uint256 _bidIncrease,
uint48 _bidDuration) public happyPath(_auction, _bid, _bidIncrease, _bidDuration) {
postSettlementSurplusAuctionHouse.increaseBidSize(_auction.id, _auction.amountToSell, _bid);
(,, address _highBidder,,) = postSettlementSurplusAuctionHouse.bids(_auction.id);
assertEq(_highBidder, user);
}
function test_Set_Bids_BidAmount(SurplusAuction memory _auction,
uint256 _bid,
uint256 _bidIncrease,
uint48 _bidDuration) public happyPath(_auction, _bid, _bidIncrease, _bidDuration) {
postSettlementSurplusAuctionHouse.increaseBidSize(_auction.id, _auction.amountToSell, _bid);
(uint256 _bidAmount,,,,) = postSettlementSurplusAuctionHouse.bids(_auction.id);
assertEq(_bidAmount, _bid);
}
function test_Set_Bids_BidExpiry(SurplusAuction memory _auction,
uint256 _bid,
uint256 _bidIncrease,
uint48 _bidDuration) public happyPath(_auction, _bid, _bidIncrease, _bidDuration) {
postSettlementSurplusAuctionHouse.increaseBidSize(_auction.id, _auction.amountToSell, _bid);
(,,, uint48 _bidExpiry,) = postSettlementSurplusAuctionHouse.bids(_auction.id);
assertEq(_bidExpiry, block.timestamp + _bidDuration);
}
function test_Emit_IncreaseBidSize(SurplusAuction memory _auction,
uint256 _bid,
uint256 _bidIncrease,
uint48 _bidDuration) public happyPath(_auction, _bid, _bidIncrease, _bidDuration) {
expectEmitNoIndex();
emit IncreaseBidSize(_auction.id, user, _auction.amountToSell, _bid, block.timestamp + _bidDuration);
postSettlementSurplusAuctionHouse.increaseBidSize(_auction.id, _auction.amountToSell, _bid);
}
}
contract Unit_PostSettlementSurplusAuctionHouse_SettleAuction is Base {
event SettleAuction(uint256 indexed _id);
modifier happyPath(SurplusAuction memory _auction) {
_assumeHappyPath(_auction);
_mockValues(_auction);
_;
}
function _assumeHappyPath(SurplusAuction memory _auction) internal view {
vm.assume(_auction.bidExpiry != 0 && (_auction.bidExpiry < block.timestamp || _auction.auctionDeadline < block.timestamp));
}
function _mockValues(SurplusAuction memory _auction) internal {
_mockAuction(_auction);
}
function test_Revert_NotFinished_0(SurplusAuction memory _auction) public {
vm.assume(_auction.bidExpiry == 0);
_mockValues(_auction);
vm.expectRevert('PostSettlementSurplusAuctionHouse/not-finished');
postSettlementSurplusAuctionHouse.settleAuction(_auction.id);
}
function test_Revert_NotFinished_1(SurplusAuction memory _auction) public {
vm.assume(_auction.bidExpiry >= block.timestamp);
vm.assume(_auction.auctionDeadline >= block.timestamp);
_mockValues(_auction);
vm.expectRevert('PostSettlementSurplusAuctionHouse/not-finished');
postSettlementSurplusAuctionHouse.settleAuction(_auction.id);
}
function test_Call_SafeEngine_TransferInternalCoins(SurplusAuction memory _auction) public happyPath(_auction) {
vm.expectCall(address(mockSafeEngine),
abi.encodeCall(mockSafeEngine.transferInternalCoins,
(address(postSettlementSurplusAuctionHouse), _auction.highBidder, _auction.amountToSell)));
postSettlementSurplusAuctionHouse.settleAuction(_auction.id);
}
function test_Call_ProtocolToken_Burn(SurplusAuction memory _auction) public happyPath(_auction) {
vm.expectCall(address(mockProtocolToken),
abi.encodeCall(mockProtocolToken.burn, (address(postSettlementSurplusAuctionHouse), _auction.bidAmount)));
postSettlementSurplusAuctionHouse.settleAuction(_auction.id);
}
function test_Set_Bids(SurplusAuction memory _auction) public happyPath(_auction) {
postSettlementSurplusAuctionHouse.settleAuction(_auction.id);
(uint256 _bidAmount, uint256 _amountToSell, address _highBidder, uint48 _bidExpiry, uint48 _auctionDeadline) =
postSettlementSurplusAuctionHouse.bids(_auction.id);
assertEq(_bidAmount, 0);
assertEq(_amountToSell, 0);
assertEq(_highBidder, address(0));
assertEq(_bidExpiry, 0);
assertEq(_auctionDeadline, 0);
}
function test_Emit_SettleAuction(SurplusAuction memory _auction) public happyPath(_auction) {
expectEmitNoIndex();
emit SettleAuction(_auction.id);
postSettlementSurplusAuctionHouse.settleAuction(_auction.id);
}
}
contract Unit_PostSettlementSurplusAuctionHouse_ModifyParameters is Base {
event ModifyParameters(bytes32 indexed _param, bytes32 indexed _cType, bytes _data);
modifier happyPath() {
vm.startPrank(authorizedAccount);
_;
}
function test_Revert_Unauthorized(bytes32 _param, bytes memory _data) public {
vm.expectRevert(IAuthorizable.Unauthorized.selector);
postSettlementSurplusAuctionHouse.modifyParameters(_param, _data);
}
function test_Set_Parameters(IPostSettlementSurplusAuctionHouse.PostSettlementSAHParams memory _fuzz)
public
happyPath
{
postSettlementSurplusAuctionHouse.modifyParameters('bidIncrease', abi.encode(_fuzz.bidIncrease));
postSettlementSurplusAuctionHouse.modifyParameters('bidDuration', abi.encode(_fuzz.bidDuration));
postSettlementSurplusAuctionHouse.modifyParameters('totalAuctionLength', abi.encode(_fuzz.totalAuctionLength));
IPostSettlementSurplusAuctionHouse.PostSettlementSAHParams memory _params =
postSettlementSurplusAuctionHouse.params();
assertEq(keccak256(abi.encode(_params)), keccak256(abi.encode(_fuzz)));
}
function test_Revert_UnrecognizedParam() public {
vm.startPrank(authorizedAccount);
vm.expectRevert(IModifiable.UnrecognizedParam.selector);
postSettlementSurplusAuctionHouse.modifyParameters('unrecognizedParam', abi.encode(0));
}
function test_Emit_ModifyParameters(uint256 _bidIncrease) public happyPath {
expectEmitNoIndex();
emit ModifyParameters('bidIncrease', GLOBAL_PARAM, abi.encode(_bidIncrease));
postSettlementSurplusAuctionHouse.modifyParameters('bidIncrease', abi.encode(_bidIncrease));
}
}
| 158,174 | 10,710 |
ec124eeee0c78549a230bd5ae42761ac0d45c75819adc729023cc01a1cce6b62
| 18,836 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/88/8854859f88ddd6bacd03e25e93e4fb23c2e6520c_GoldenAvax.sol
| 4,190 | 15,805 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract GoldenAvax 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 = 'GoldenAvax';
string private _symbol = 'GoldenAvax';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(11);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 81,827 | 10,711 |
d1969a639c0b4facdb5c013050e9697075d9753595f02a7006eb9e887a03e9e7
| 19,431 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x8f18106d17a1349e189524d6199bd9b801955021.sol
| 9,504 | 16,513 |
pragma solidity ^0.4.21 ;
contract RE_Portfolio_X_883 {
mapping (address => uint256) public balanceOf;
string public name = " RE_Portfolio_X_883 " ;
string public symbol = " RE883X " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 1724616534055050000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value; // deduct from sender's balance
balanceOf[to] += value; // add to recipient's balance
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
// }
// Programme d'mission - Lignes 1 10
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RE_Portfolio_X_metadata_line_1_____European_Reinsurance_Consultants_20250515 >
// < D8v81h27FBSiRtPlNUVdolxTsvg4ncf8r2M34lMwYWEh286X5H0sH4mMd88cC0JA >
// < 1E-018 limites [ 1E-018 ; 35205224,2350521 ] >
// < 0x00000000000000000000000000000000000000000000000000000000D1D6EAAB >
// < RE_Portfolio_X_metadata_line_2_____Everest_National_Insurance_Co_Ap_Ap_20250515 >
// < 7dMdUH7TN5u875a70BvW0rJwCv1zhkdpTrQtH3RUXHd0q9HYKmURM2caVGPy2jjh >
// < 1E-018 limites [ 35205224,2350521 ; 98251222,5673903 ] >
// < 0x00000000000000000000000000000000000000000000000D1D6EAAB2499F79C4 >
// < RE_Portfolio_X_metadata_line_3_____Everest_Re_Group_20250515 >
// < zVF0rYI70D7b0OZ2tojFJGC48T2J60L6hnLWuW71Jgu8jq5Fv9G6mTz6y1kvd44n >
// < 1E-018 limites [ 98251222,5673903 ; 154556676,857003 ] >
// < 0x00000000000000000000000000000000000000000000002499F79C43993AC7D9 >
// < RE_Portfolio_X_metadata_line_4_____Everest_Re_Group_20250515 >
// < rlKfySod6adx9adzH5n5Z6hQA599J1O77VIe50sS73qa4ua3Rdu6qy43vrXl8aa2 >
// < 1E-018 limites [ 154556676,857003 ; 207287970,828712 ] >
// < 0x00000000000000000000000000000000000000000000003993AC7D94D388598E >
// < RE_Portfolio_X_metadata_line_5_____Everest_Re_Group_20250515 >
// < uqVK1eBQilSmY2VV14N9Ms0tum5s45uC02850O18UToO2G7TOjj21N3zO8b25ij5 >
// < 1E-018 limites [ 207287970,828712 ; 220688404,426694 ] >
// < 0x00000000000000000000000000000000000000000000004D388598E52367C9EE >
// < RE_Portfolio_X_metadata_line_6_____Everest_Re_Group_Limited_20250515 >
// < n28srWQSUFTx3r0vWdoIE02pw9w7H8f02OCKNEPWe6BK86x09jobh6UT933Ji61m >
// < 1E-018 limites [ 220688404,426694 ; 294655852,371998 ] >
// < 0x000000000000000000000000000000000000000000000052367C9EE6DC492849 >
// < qob52coqYbYlaI70L3P2k4U5Rr3AGG7e36r2IrtsVXd7342497XUEY6V6821Xh3f >
// < 1E-018 limites [ 294655852,371998 ; 354261799,826067 ] >
// < 0x00000000000000000000000000000000000000000000006DC49284983F909D82 >
// < RE_Portfolio_X_metadata_line_8_____Evergreen_Re_20250515 >
// < VZKXtWFqx1zsJouVbp67WpICU0MAIjHBRW7i2437HM47HjFZ4SliEJ4Z02Hc565N >
// < 1E-018 limites [ 354261799,826067 ; 378253365,098779 ] >
// < 0x000000000000000000000000000000000000000000000083F909D828CE90D6B1 >
// < RE_Portfolio_X_metadata_line_9_____EWI_Re_Intermediaries_and_Consultants_20250515 >
// < bk1WAE4jxce00Cua4l2z9Fib0Xo1NokvEukEQrZ3UmT7VKpfzwDMfsN9vgwuzp70 >
// < 1E-018 limites [ 378253365,098779 ; 456146448,873707 ] >
// < 0x00000000000000000000000000000000000000000000008CE90D6B1A9ED8408B >
// < RE_Portfolio_X_metadata_line_10_____Factory_Mutual_Insurance_Co_Ap_Ap_20250515 >
// < LeCPC7IVqW6ivvM23iYzV800fXES92fdV5Ro5Ry2h28r7j0pyWCZ8b3vI7F5HfjV >
// < 1E-018 limites [ 456146448,873707 ; 471398070,734583 ] >
// < 0x0000000000000000000000000000000000000000000000A9ED8408BAF9C06155 >
// Programme d'mission - Lignes 11 20
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RE_Portfolio_X_metadata_line_11_____Faraday_Underwriting_Limited_20250515 >
// < 7py5tEh3TTSM3D511qSeMRPC62csW1LC5iI8s31vA9xL32861Y3XPXHNl6teScrL >
// < 1E-018 limites [ 471398070,734583 ; 552066324,876761 ] >
// < 0x0000000000000000000000000000000000000000000000AF9C06155CDA925E1B >
// < RE_Portfolio_X_metadata_line_12_____Faraday_Underwriting_Limited_20250515 >
// < Y6yqnZK075G96m9O12i52DpIc0v8W9jT77QDneVt74gO13Si4GX1yc4ccx1S583Y >
// < 1E-018 limites [ 552066324,876761 ; 565449517,856386 ] >
// < 0x0000000000000000000000000000000000000000000000CDA925E1BD2A577FDD >
// < RE_Portfolio_X_metadata_line_13_____Faraday_Underwriting_Limited_20250515 >
// < 4uGick1mI3SyVF8dzqi27gwx7x0YlD546GXb563zKAl9enL859W0qO48a9U0SB26 >
// < 1E-018 limites [ 565449517,856386 ; 639504901,630417 ] >
// < 0x0000000000000000000000000000000000000000000000D2A577FDDEE3BF0C27 >
// < RE_Portfolio_X_metadata_line_14_____Faraday_Underwriting_Limited_20250515 >
// < D8HgeA7KQzg8s1AHncyFky9nW6p4fi3DJGv8NHbT72fKVMQlk5Mwul9pmt6quAc1 >
// < 1E-018 limites [ 639504901,630417 ; 715695508,049936 ] >
// < 0x000000000000000000000000000000000000000000000EE3BF0C2710A9E0AFC8 >
// < RE_Portfolio_X_metadata_line_15_____Fiduciary_Intermediary_20250515 >
// < N1fu7Si68f14m7i6YLiSVQ97qz33861Fy04zi7nRGTP4mt87wi1K167Gr5b0kX74 >
// < 1E-018 limites [ 715695508,049936 ; 743637461,618944 ] >
// < 0x0000000000000000000000000000000000000000000010A9E0AFC811506CB965 >
// < RE_Portfolio_X_metadata_line_16_____First_Capital_Insurance_Limited_A_20250515 >
// < wCBWF7V08gp0mSoLL40cA1BVxgR2sCZLMx5dUxtq78Dg9wSc9PyWBJ0KECQLM2sm >
// < 1E-018 limites [ 743637461,618944 ; 785991183,168893 ] >
// < 0x0000000000000000000000000000000000000000000011506CB965124CDF5FE0 >
// < EdxgK3q0a8D23GYrTX0zPG9026O9HHQ37v1T2z3FX9wSXkK7ks2Xg8F9AWEoP81n >
// < 1E-018 limites [ 785991183,168893 ; 846829386,163266 ] >
// < 0x00000000000000000000000000000000000000000000124CDF5FE013B77F1AEC >
// < RE_Portfolio_X_metadata_line_18_____FolksAmerica_Reinsurance_Company_20250515 >
// < 87qV9kH2SsA408r95gSXjBrv84sAzHn82hfLujCOY8dn6xwh8WpK37S9lnr9V3Er >
// < 1E-018 limites [ 846829386,163266 ; 901925330,651468 ] >
// < 0x0000000000000000000000000000000000000000000013B77F1AEC14FFE4D83D >
// < RE_Portfolio_X_metadata_line_19_____GBG_Insurance_limited_USA_Bpp_20250515 >
// < j7j5mAMiZ2XJAy7W6g9M47b805wjn0b0W8NDPS1hcYChUFTvVX180ILar64i5se5 >
// < 1E-018 limites [ 901925330,651468 ; 963613439,131181 ] >
// < 0x0000000000000000000000000000000000000000000014FFE4D83D166F956D9D >
// < RE_Portfolio_X_metadata_line_20_____GE_ERC_20250515 >
// < B8lQQKxTfltr7IydVrtZS21V742Trp5dxnuNYubmnk4P603r3011240BbP1haHng >
// < 1E-018 limites [ 963613439,131181 ; 1007149153,42193 ] >
// < 0x00000000000000000000000000000000000000000000166F956D9D177313A802 >
// Programme d'mission - Lignes 21 30
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RE_Portfolio_X_metadata_line_21_____General_Cologne_Re_20250515 >
// < 47zVCP1yaRw527wI9To02P6A4l1L0XWrb89oKmKJmiA1iNy6UXz15z9p0y04bzW5 >
// < 1E-018 limites [ 1007149153,42193 ; 1048176399,60965 ] >
// < 0x00000000000000000000000000000000000000000000177313A80218679E440C >
// < WcI8agjWu00HLuOXPcgIW93U4dRsd38ayqQBM3z4918HsPojU053Tu8523e02zA3 >
// < 1E-018 limites [ 1048176399,60965 ; 1094781549,32812 ] >
// < 0x0000000000000000000000000000000000000000000018679E440C197D6814A8 >
// < b272RujYz55e4526K3x06I4oTnW3v6swg4jJ53mCS6o697FHsCjYZmv1lq10CmmK >
// < 1E-018 limites [ 1094781549,32812 ; 1105997978,5313 ] >
// < 0x00000000000000000000000000000000000000000000197D6814A819C042FE51 >
// < RE_Portfolio_X_metadata_line_24_____General_Re_Co_AA_App_20250515 >
// < 8iSY8q4g0I1EKYi3nXL0G127S4h5N1C8ChR9NGjW9gk9sQ35KLSB9lzK3572U7q3 >
// < 1E-018 limites [ 1105997978,5313 ; 1170640506,34888 ] >
// < 0x0000000000000000000000000000000000000000000019C042FE511B418FA9BE >
// < RE_Portfolio_X_metadata_line_25_____General_Reinsurance_AG_AAm_App_20250515 >
// < 506mnh92Qnjd98H6JGPEePJSjqZK2WFVwPP9scSh8mg755V2aQ975ghBj8tY6I58 >
// < 1E-018 limites [ 1170640506,34888 ; 1205540508,06079 ] >
// < 0x000000000000000000000000000000000000000000001B418FA9BE1C1194D6EA >
// < NwJ56wpssU33BXRh5tpJX7z8G7nVP7A86RmpIy1704a324a51YL6Qb5IPs7iZ3r1 >
// < 1E-018 limites [ 1205540508,06079 ; 1228073254,88163 ] >
// < 0x000000000000000000000000000000000000000000001C1194D6EA1C97E31524 >
// < RE_Portfolio_X_metadata_line_27_____Generali_Group_20250515 >
// < GXdph0Ey7ht53Wx46rI7r34Nw1lRYp91gwe5em47xjL0vDyzrGk86P5NcUgh8u7f >
// < 1E-018 limites [ 1228073254,88163 ; 1246314210,20301 ] >
// < 0x000000000000000000000000000000000000000000001C97E315241D049C9250 >
// < RE_Portfolio_X_metadata_line_28_____Generali_Itallia_SPA_A_20250515 >
// < EziC4N6N8Qe526PTj2qjeB3J9ifpKAp4z98XXnA8RHfwl4898g0z71r6kuAfMdui >
// < 1E-018 limites [ 1246314210,20301 ; 1262776759,6049 ] >
// < 0x000000000000000000000000000000000000000000001D049C92501D66BC6DAC >
// < RE_Portfolio_X_metadata_line_29_____Gerling_Global_Financial_Services_20250515 >
// < 57Z6p79tqy4VdQ8ee6Efw61KbZm29UoSnke0QYrK172YX7x262E4HJHbNoyBqxYQ >
// < 1E-018 limites [ 1262776759,6049 ; 1317515363,57484 ] >
// < 0x000000000000000000000000000000000000000000001D66BC6DAC1EAD00E8D9 >
// < RE_Portfolio_X_metadata_line_30_____Gerling_Global_Re_20250515 >
// < fndhvrI82gqh4b104s4xyGE551oJj45LaBnbE1G2Fu0pK47Z04R123F9V4R370Rs >
// < 1E-018 limites [ 1317515363,57484 ; 1328252163,78192 ] >
// < 0x000000000000000000000000000000000000000000001EAD00E8D91EECFFF76E >
// Programme d'mission - Lignes 31 40
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RE_Portfolio_X_metadata_line_31_____Gerling_Reinsurance_Australia_20250515 >
// < S54BBy0WgSerb40zls8mmfM4b1R0Nks7D5xXz72B2H9WfeYnfR3t47uQxZo7YOnj >
// < 1E-018 limites [ 1328252163,78192 ; 1389263686,16927 ] >
// < 0x000000000000000000000000000000000000000000001EECFFF76E2058A8295C >
// < RE_Portfolio_X_metadata_line_32_____Ghana_Re_20250515 >
// < Xep07ob9dGSp2d2ELyw3c9dOyffxB8oX9zu3M2J69KFD1doYAugrz5932v0Oslg4 >
// < 1E-018 limites [ 1389263686,16927 ; 1412155401,035 ] >
// < 0x000000000000000000000000000000000000000000002058A8295C20E11A257B >
// < RE_Portfolio_X_metadata_line_33_____Gill_and_Roeser_20250515 >
// < shI4a8zbvo3kvH7js7M43Px1i5nGGX3L9Xrp9Alq1UvKK7I95347d3ZAMbz145u0 >
// < 1E-018 limites [ 1412155401,035 ; 1443837426,52427 ] >
// < 0x0000000000000000000000000000000000000000000020E11A257B219DF114B0 >
// < RE_Portfolio_X_metadata_line_34_____Glacier_Group_20250515 >
// < 62GoA3czxuX9gX3IEKduaWWrrYYbwQat1qco9swKndtE6qP590eFL6h7CF1ezsdx >
// < 1E-018 limites [ 1443837426,52427 ; 1514306817,90679 ] >
// < 0x00000000000000000000000000000000000000000000219DF114B02341F8D6B2 >
// < RE_Portfolio_X_metadata_line_35_____Glacier_Group_20250515 >
// < pVa1i24T24zGsciDN2N3c0yUGJOOW7DnufLAflv52tV2r5bfdsjuzwcg5GHhT5FI >
// < 1E-018 limites [ 1514306817,90679 ; 1561105223,20555 ] >
// < 0x000000000000000000000000000000000000000000002341F8D6B22458E989C4 >
// < RE_Portfolio_X_metadata_line_36_____Global_Reinsurance_20250515 >
// < xT7tNv6JsRskofyS3F849821DH9VKA1a1f0G4rdfyYP9FIcvz6b4NfG5B2Ezm9K2 >
// < 1E-018 limites [ 1561105223,20555 ; ] >
// < 0x000000000000000000000000000000000000000000002458E989C424E6F08D4D >
// < RE_Portfolio_X_metadata_line_37_____GMAC_Re_20250515 >
// < jU4CJnL0d97607640u99MyrRrV71KC4iXmmEMe6O8G9g7as04cUrUUx5TwpB8bk8 >
// < 1E-018 limites [ 1584933466,49313 ; 1653537746,74199 ] >
// < 0x0000000000000000000000000000000000000000000024E6F08D4D267FDA6046 >
// < RE_Portfolio_X_metadata_line_38_____GMF_Assurances_BBB_Baa3_20250515 >
// < 79vx3Blc8rW03wG3jNL6ugR9Cg7MuV3tuA7Z6J1U6a57NHb16G9zv399oc8S3cBt >
// < 1E-018 limites [ 1653537746,74199 ; 1670808102,81451 ] >
// < 0x00000000000000000000000000000000000000000000267FDA604626E6CAD91D >
// < qz5CMsmU5s3f5aYBM92Y8d6l25K97x14mG49ysfB6DhP5pyuW3r0wEA595jOHrkO >
// < 1E-018 limites [ 1670808102,81451 ; 1697655608,00777 ] >
// < 0x0000000000000000000000000000000000000000000026E6CAD91D2786D0E3D4 >
// < d728oj78xG9405BgT69TPvGmuIv9tBo0p89hNad0eP69qh4k7Q72jnAX5BeKv1OV >
// < 1E-018 limites [ 1697655608,00777 ; 1724616534,05505 ] >
// < 0x000000000000000000000000000000000000000000002786D0E3D4282783FF91 >
}
| 148,012 | 10,712 |
e63ade845fda2d63d1279a1dbd07531f3985217611086a07f39b7827ccc12c87
| 28,813 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00000000f2cfa550ad4aae0f33bcaad5164900be.sol
| 4,813 | 18,901 |
pragma solidity ^0.8.6;
// SPDX-License-Identifier: UNLICENSED
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address payable private _owner;
address payable private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = payable(address(0));
}
function transferOwnership(address payable newOwner)
public
virtual
onlyOwner
{
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function getUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = payable(address(0));
_lockTime = block.timestamp + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender,
"You don't have permission to unlock");
require(block.timestamp > _lockTime,
"Contract is locked until defined days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
_previousOwner = payable(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 Stealth is Context, IERC20, Ownable {
using SafeMath for uint256;
// If you are reading this then welcome - this is where the work happens.
// StealthStandard Check
mapping (address => uint256) private _balances;
mapping (address => uint256) private _firstBuy;
mapping (address => uint256) private _lastBuy;
mapping (address => uint256) private _lastSell;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _hasTraded;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant _tTotal = 1000000000000 * 10**18;
uint256 private _tradingStartTimestamp;
uint256 public sellCoolDownTime = 60 seconds;
uint256 private minTokensToSell = _tTotal.div(100000);
address payable private _stealthMultiSigWallet;
string private constant _name = "Stealth Standard";
string private constant _symbol = "$STEALTH";
uint8 private constant _decimals = 18;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = false;
bool private antiBotEnabled = false;
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_stealthMultiSigWallet = payable(0x852a8cb5D5e09133EDa0713C1A475A5B7dE80226);
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = _uniswapV2Pair;
_balances[_msgSender()] = _tTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_stealthMultiSigWallet] = 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");
require(balanceOf(from) >= amount,"Not enough balance for tx");
// Check if we are buying or selling, or simply transferring
if ((to == uniswapV2Pair) && ! _isExcludedFromFee[from]) {
// Selling to uniswapV2Pair:
// ensure trading is open
require(tradingOpen,"trading is not yet open");
// Block known bots from selling - If you think this was a mistake please contact the Stealth Team
require(!bots[from], "Stealth is a Bot Free Zone");
// anti bot code - checks for buys and sells in the same block or within the sellCoolDownTime
if (antiBotEnabled) {
uint256 lastBuy = _lastBuy[from];
require(block.timestamp > lastBuy, "Sorry - no FrontRunning allowed right now");
require(cooldown[from] < block.timestamp);
cooldown[from] = block.timestamp + sellCoolDownTime;
}
// Has Seller made a trade before? If not set to current block timestamp
// We check this again on a sell to make sure they didn't transfer to a new wallet
if (!_hasTraded[from]){
_firstBuy[from] = block.timestamp;
_hasTraded[from] = true;
}
if (swapEnabled) {
// handle sell of tokens in contract for Eth
uint256 contractTokenBalance = balanceOf(address(this));
if (contractTokenBalance >= minTokensToSell) {
if (!inSwap) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToWallet(address(this).balance);
}
}
}
}
// Check to see if just taking profits or selling over 5%
bool justTakingProfits = _justTakingProfits(amount, from);
uint256 numHours = _getHours(_lastSell[from], block.timestamp);
uint256 numDays = (numHours / 24);
if (justTakingProfits) {
// just taking profits but need to make sure its been more than 7 days since last sell if so
if (numDays < 7) {
_firstBuy[from] = block.timestamp;
_lastBuy[from] = block.timestamp;
}
} else {
if (numDays < 84) {
// sold over 5% so we reset the last buy to be now
_firstBuy[from] = block.timestamp;
_lastBuy[from] = block.timestamp;
}
}
// Record last sell timestamp
_lastSell[from] = block.timestamp;
// Transfer with taxes
_tokenTransferTaxed(from,to,amount);
} else if ((from == uniswapV2Pair) && ! _isExcludedFromFee[to]) {
// Buying from uniswapV2Pair:
// ensure trading is open
require(tradingOpen,"trading is not yet open");
// Has buyer made a trade before? If not set to current block timestamp
if (!_hasTraded[to]){
_firstBuy[to] = block.timestamp;
_hasTraded[to] = true;
}
// snapshot the last buy timestamp
_lastBuy[to] = block.timestamp;
// Simple Transfer with no taxes
_transferFree(from, to, amount);
} else {
// Other transfer
// Block known bots from selling - If you think this was a mistake please contact the Stealth Team
require(!bots[from] && !bots[to], "Stealth is a Bot Free Zone");
// Handle the case of wallet to wallet transfer
_firstBuy[to] = block.timestamp;
_hasTraded[to] = true;
// Simple Transfer with no taxes
_transferFree(from, to, amount);
}
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
// If we are doing a tax free Transfer that happens here after _transfer:
function _transferFree(address sender, address recipient, uint256 tAmount) private {
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tAmount);
emit Transfer(sender, recipient, tAmount);
}
// If we are doing a taxed Transfer that happens here after _transfer:
function _tokenTransferTaxed(address sender, address recipient, uint256 amount) private {
_transferTaxed(sender, recipient, amount);
}
function _transferTaxed(address sender, address recipient, uint256 tAmount) private {
// Calculate the taxed token amount
uint256 tTeam = _getTaxedValue(tAmount, sender);
uint256 transferAmount = tAmount - tTeam;
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(transferAmount);
_takeTeam(tTeam);
emit Transfer(sender, recipient, transferAmount);
}
function _takeTeam(uint256 tTeam) private {
_balances[address(this)] = _balances[address(this)].add(tTeam);
}
// Check to see if the sell amount is greater than 5% of tokens in a 7 day period
function _justTakingProfits(uint256 sellAmount, address account) private view returns(bool) {
// Basic cheak to see if we are selling more than 5% - if so return false
if ((sellAmount * 20) > _balances[account]) {
return false;
} else {
return true;
}
}
// Calculate the number of taxed tokens for a transaction
function _getTaxedValue(uint256 transTokens, address account) private view returns(uint256){
uint256 taxRate = _getTaxRate(account);
if (taxRate == 0) {
return 0;
} else {
uint256 numerator = (transTokens * (10000 - (100 * taxRate)));
return (((transTokens * 10000) - numerator) / 10000);
}
}
// Calculate the current tax rate.
function _getTaxRate(address account) private view returns(uint256) {
uint256 numHours = _getHours(_tradingStartTimestamp, block.timestamp);
if (numHours <= 24){
// 20% Sell Tax first 24 Hours
return 20;
} else if (numHours <= 48){
// 16% Sell Tax second 24 Hours
return 16;
} else {
// 12% Sell Tax starting rate
numHours = _getHours(_firstBuy[account], block.timestamp);
uint256 numDays = (numHours / 24);
if (numDays >= 84){
//12 x 7 = 84 = tax free!
return 0;
} else {
uint256 numWeeks = (numDays / 7);
return (12 - numWeeks);
}
}
}
// Calculate the number of hours that have passed between endDate and startDate:
function _getHours(uint256 startDate, uint256 endDate) private pure returns(uint256){
return ((endDate - startDate) / 60 / 60);
}
receive() external payable {}
function manualswap() external {
require(_msgSender() == _stealthMultiSigWallet || _msgSender() == address(this) || _msgSender() == owner());
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _stealthMultiSigWallet || _msgSender() == address(this) || _msgSender() == owner());
uint256 contractETHBalance = address(this).balance;
sendETHToWallet(contractETHBalance);
}
function airdrop(address[] memory _user, uint256[] memory _amount) external onlyOwner {
uint256 len = _user.length;
require(len == _amount.length);
for (uint256 i = 0; i < len; i++) {
_balances[_msgSender()] = _balances[_msgSender()].sub(_amount[i], "ERC20: transfer amount exceeds balance");
_balances[_user[i]] = _balances[_user[i]].add(_amount[i]);
emit Transfer(_msgSender(), _user[i], _amount[i]);
}
}
function setMultipleBots(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function setBot(address isbot) public onlyOwner {
bots[isbot] = true;
}
function deleteBot(address notbot) public onlyOwner {
bots[notbot] = false;
}
function isBlacklisted(address isbot) public view returns(bool) {
return bots[isbot];
}
function setAntiBotMode(bool onoff) external onlyOwner() {
antiBotEnabled = onoff;
}
function isAntiBotEnabled() public view returns(bool) {
return antiBotEnabled;
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setSellCoolDownTime(uint256 _newTime) public onlyOwner {
sellCoolDownTime = _newTime;
}
function updateRouter(IUniswapV2Router02 newRouter, address newPair) external onlyOwner {
uniswapV2Router = newRouter;
uniswapV2Pair = newPair;
}
function sendETHToWallet(uint256 amount) private {
_stealthMultiSigWallet.transfer(amount);
}
function startTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
antiBotEnabled = true;
swapEnabled = true;
tradingOpen = true;
_tradingStartTimestamp = block.timestamp;
}
function setSwapEnabledMode(bool swap) external onlyOwner {
swapEnabled = swap;
}
function isTradingOpen() public view returns(bool) {
return tradingOpen;
}
}
| 344,358 | 10,713 |
683b3eb7f350f0201e67df8bf3e6bb7ef34f7ac134327bb4160292120e3652f2
| 34,166 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/21/21708c0ba987b2c1af45cea14ab94a53f553f12b_LGN.sol
| 4,192 | 16,184 |
// 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;
}
}
// Part: IERC20
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// Part: 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: ERC20
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 { }
}
// 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: ERC20Capped
abstract contract ERC20Capped is ERC20 {
using SafeMath for uint256;
uint256 private _cap;
constructor (uint256 cap_) internal {
require(cap_ > 0, "ERC20Capped: cap is 0");
_cap = cap_;
}
function cap() public view virtual returns (uint256) {
return _cap;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) { // When minting tokens
require(totalSupply().add(amount) <= cap(), "ERC20Capped: cap exceeded");
}
}
}
// File: LEGION.sol
// Token with Governance.
contract LGN is ERC20Capped, Ownable {
using SafeMath for uint256;
constructor(string memory _name, string memory _symbol, uint256 _cap) ERC20(_name, _symbol) ERC20Capped(_cap) public {}
/// @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);
}
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;
}
}
| 26,647 | 10,714 |
b90e42a70e8131ab6cf63c85f072dfe53f21d38d837a52e660d43206ff86e441
| 15,208 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xe467b8d9b0c69f7d497b8f002a9e7f4b61c84c67.sol
| 3,652 | 12,667 |
pragma solidity 0.4.24;
library SafeMathExt{
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 pow(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0){
return 1;
}
if (b == 1){
return a;
}
uint256 c = a;
for(uint i = 1; i<b; i++){
c = mul(c, a);
}
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function roundUp(uint256 a, uint256 b) public pure returns(uint256){
// ((a + b - 1) / b) * b
uint256 c = (mul(div(sub(add(a, b), 1), b), b));
return c;
}
}
contract BadgeFactoryInterface{
function _initBadges(address admin_, uint256 badgeBasePrice_, uint256 badgeStartMultiplier_, uint256 badgeStartQuantity_) external;
function _createNewBadge(address owner_, uint256 price_) external;
function _setOwner(uint256 badgeID_, address owner_) external;
function getOwner(uint256 badgeID_) public view returns(address);
function _increasePrice(uint256 badgeID_) external;
function getPrice(uint256 badgeID_) public view returns(uint256);
function _increaseTotalDivis(uint256 badgeID_, uint256 divis_) external;
function getTotalDivis(uint256 badgeID_) public view returns(uint256);
function _setBuyTime(uint256 badgeID_, uint32 timeStamp_) external;
function getBuyTime(uint256 badgeID_) public view returns(uint32);
function getCreationTime(uint256 badgeID_) public view returns(uint32);
function getChainLength() public view returns(uint256);
function getRandomBadge(uint256 max_, uint256 i_) external view returns(uint256);
function getRandomFactor() external returns(uint256);
}
contract TeamAmberInterface{
function distribute() public payable;
}
contract Amber{
using SafeMathExt for uint256;
BadgeFactoryInterface internal _badgeFactory;
TeamAmberInterface internal _teamAmber;
uint256 internal constant GWEI = 10**9;
uint256 internal constant FINNEY = 10**15;
uint256 internal constant ETH = 10**18;
uint256 internal constant _badgeBasePrice = 25 * FINNEY;
uint256 internal constant _luckyWinners = 5;
uint256 internal constant _sharePreviousOwnerRatio = 50;
uint256 internal constant _shareReferalRatio = 5;
uint256 internal constant _shareDistributionRatio = 45;
address internal _contractOwner;
address internal _admin;
uint256 internal _startTime;
uint256 internal _initCounter;
struct Badge{
address owner;
uint256 price;
uint256 totalDivis;
}
Badge[] private badges;
mapping(address => uint256) private _splitProfit;
mapping(address => uint256) private _flipProfit;
mapping(address => uint256) private _waypointProfit;
mapping(address => address) private _referer;
event onContractStart(uint256 startTime_);
event onRefererSet(address indexed user_, address indexed referer_);
event onBadgeBuy(uint256 indexed badgeID_, address previousOwner_, address indexed buyer_, address indexed referer_, uint256 price_, uint256 newPrice_);
event onWithdraw(address indexed receiver_, uint256 splitProfit_, uint256 flipProfit_, uint256 waypointProfit_);
modifier onlyContractOwner(){
require(msg.sender == _contractOwner, 'Sender is not the contract owner.');
_;
}
modifier isNotAContract(){
require (msg.sender == tx.origin, 'Contracts are not allowed to interact.');
_;
}
modifier isRunning(){
require(_startTime != 0 && _startTime <= now, 'The contract is not running yet.');
_;
}
function isValidBuy(uint256 price_, uint256 msgValue_) public pure returns(bool){
return (price_ == msgValue_);
}
function refererAllowed(address msgSender_, address currentReferer_, address newReferer_) public pure returns(bool){
return (addressNotSet(currentReferer_) && isAddress(newReferer_) && isNotSelf(msgSender_, newReferer_));
}
function addressNotSet(address address_) public pure returns(bool){
return (address_ == 0x0);
}
function isAddress(address address_) public pure returns(bool){
return (address_ != 0x0);
}
function isNotSelf(address msgSender_, address compare_) public pure returns(bool){
return (msgSender_ != compare_);
}
function isFirstBadgeEle(uint256 badgeID_) public pure returns(bool){
return (badgeID_ == 0);
}
function isLastBadgeEle(uint256 badgeID_, uint256 badgeLength_) public pure returns(bool){
assert(badgeID_ <= SafeMathExt.sub(badgeLength_, 1));
return (badgeID_ == SafeMathExt.sub(badgeLength_, 1));
}
function calcShare(uint256 msgValue_, uint256 ratio_) public pure returns(uint256){
assert(ratio_ <= 100 && msgValue_ >= 0);
return (msgValue_ * ratio_) / 100;
}
function _initBadges(address[] owner_, uint256[] price_, uint256[] totalDivis_) internal{
for (uint256 i = 0; i < owner_.length; i++) {
badges.push(Badge(owner_[i], price_[i], totalDivis_[i]));
}
}
function _createNewBadge(address owner_, uint256 price_) internal{
badges.push(Badge(owner_, price_, 0));
}
function _setOwner(uint256 badgeID_, address owner_) internal{
badges[badgeID_].owner = owner_;
}
function getOwner(uint256 badgeID_) public view returns(address){
return badges[badgeID_].owner;
}
function _increasePrice(uint256 badgeID_) internal{
uint256 newPrice = (badges[badgeID_].price * _badgeFactory.getRandomFactor()) / 100;
badges[badgeID_].price = SafeMathExt.roundUp(newPrice, 10000 * GWEI);
}
function getPrice(uint256 badgeID_) public view returns(uint256){
return badges[badgeID_].price;
}
function _increaseTotalDivis(uint256 badgeID_, uint256 divis_) internal{
badges[badgeID_].totalDivis += divis_;
}
function getTotalDivis(uint256 badgeID_) public view returns(uint256){
return badges[badgeID_].totalDivis;
}
function getChainLength() public view returns(uint256){
return badges.length;
}
constructor(address admin_, address teamAmberAddress_) public{
_contractOwner = msg.sender;
_admin = admin_;
_teamAmber = TeamAmberInterface(teamAmberAddress_);
}
function initGame(address badgesFactoryAddress_, address[] owner_, uint256[] price_, uint256[] totalDivis_) external onlyContractOwner{
require(_startTime == 0);
assert(owner_.length == price_.length && price_.length == totalDivis_.length);
if(_badgeFactory == address(0x0)){
_badgeFactory = BadgeFactoryInterface(badgesFactoryAddress_);
}
_initBadges(owner_, price_, totalDivis_);
}
function initReferrals(address[] refArray_) external onlyContractOwner{
require(_startTime == 0);
for (uint256 i = 0; i < refArray_.length; i+=2) {
_refererUpdate(refArray_[i], refArray_[i+1]);
}
}
function _startContract(uint256 delay_) external onlyContractOwner{
require(_startTime == 0);
_startTime = now + delay_;
emit onContractStart(_startTime);
}
//Hex Data: 0x7deb6025
function buy(uint256 badgeID_, address newReferer_) public payable isNotAContract isRunning{
_refererUpdate(msg.sender, newReferer_);
_buy(badgeID_, newReferer_, msg.sender, msg.value);
}
function _buy(uint256 badgeID_, address newReferer_, address msgSender_, uint256 msgValue_) internal{
address previousOwner = getOwner(badgeID_);
require(isNotSelf(msgSender_, getOwner(badgeID_)), 'You can not buy from yourself.');
require(isValidBuy(getPrice(badgeID_), msgValue_), 'It is not a valid buy.');
_diviSplit(badgeID_, previousOwner, msgSender_, msgValue_);
_extendBadges(badgeID_, msgSender_, _badgeBasePrice);
_badgeOwnerChange(badgeID_, msgSender_);
_increasePrice(badgeID_);
emit onBadgeBuy(badgeID_, previousOwner, msgSender_, newReferer_, msgValue_, getPrice(badgeID_));
}
function _refererUpdate(address user_, address newReferer_) internal{
if (refererAllowed(user_, _referer[user_], newReferer_)){
_referer[user_] = newReferer_;
emit onRefererSet(user_, newReferer_);
}
}
function _extendBadges(uint256 badgeID_, address owner_, uint256 price_) internal{
if (isLastBadgeEle(badgeID_, getChainLength())){
_createNewBadge(owner_, price_);
}
}
function _badgeOwnerChange(uint256 badgeID_, address newOwner_) internal{
_setOwner(badgeID_, newOwner_);
}
function _diviSplit(uint256 badgeID_, address previousOwner_, address msgSender_, uint256 msgValue_) internal{
_shareToDistribution(badgeID_, msgValue_, _shareDistributionRatio);
_shareToPreviousOwner(previousOwner_, msgValue_, _sharePreviousOwnerRatio);
_shareToReferer(_referer[msgSender_], msgValue_, _shareReferalRatio);
}
function _shareToDistribution(uint256 badgeID_, uint256 msgValue_, uint256 ratio_) internal{
uint256 share = calcShare(msgValue_, ratio_) / _luckyWinners;
uint256 idx;
for(uint256 i = 0; i < _luckyWinners; i++){
idx = _badgeFactory.getRandomBadge(badgeID_, i);
_increaseTotalDivis(idx, share);
_splitProfit[getOwner(idx)] += share;
}
}
function _shareToPreviousOwner(address previousOwner_, uint256 msgValue_, uint256 ratio_) internal{
_flipProfit[previousOwner_] += calcShare(msgValue_, ratio_);
}
function _shareToReferer(address referer_, uint256 msgValue_, uint256 ratio_) internal{
if (addressNotSet(referer_)){
_waypointProfit[_admin] += calcShare(msgValue_, ratio_);
} else {
_waypointProfit[referer_] += calcShare(msgValue_, ratio_);
}
}
//Hex Data: 0x853828b6
function withdrawAll() public isNotAContract{
uint256 splitProfit = _splitProfit[msg.sender];
_splitProfit[msg.sender] = 0;
uint256 flipProfit = _flipProfit[msg.sender];
_flipProfit[msg.sender] = 0;
uint256 waypointProfit = _waypointProfit[msg.sender];
_waypointProfit[msg.sender] = 0;
_transferDivis(msg.sender, splitProfit + flipProfit + waypointProfit);
emit onWithdraw(msg.sender, splitProfit, flipProfit, waypointProfit);
}
function _transferDivis(address msgSender_, uint256 payout_) internal{
assert(address(this).balance >= payout_);
if(msgSender_ == _admin){
_teamAmber.distribute.value(payout_)();
} else {
msgSender_.transfer(payout_);
}
}
function getStartTime() public view returns (uint256){
return _startTime;
}
function getSplitProfit(address user_) public view returns(uint256){
return _splitProfit[user_];
}
function getFlipProfit(address user_) public view returns(uint256){
return _flipProfit[user_];
}
function getWaypointProfit(address user_) public view returns(uint256){
return _waypointProfit[user_];
}
function getReferer(address user_) public view returns(address){
return _referer[user_];
}
function getBalanceContract() public view returns(uint256){
return address(this).balance;
}
function getAllBadges() public view returns(address[], uint256[], uint256[]){
uint256 chainLength = getChainLength();
return (getBadges(0, chainLength-1));
}
function getBadges(uint256 _from, uint256 _to) public view returns(address[], uint256[], uint256[]){
require(_from <= _to, 'Index FROM needs to be smaller or same than index TO');
address[] memory owner = new address[](_to - _from + 1);
uint256[] memory price = new uint256[](_to - _from + 1);
uint256[] memory totalDivis = new uint256[](_to - _from + 1);
for (uint256 i = _from; i <= _to; i++) {
owner[i - _from] = getOwner(i);
price[i - _from] = getPrice(i);
totalDivis[i - _from] = getTotalDivis(i);
}
return (owner, price, totalDivis);
}
}
| 221,168 | 10,715 |
9048420777d4b96134c0bcced682340b07fa70e29d8c21a3ad80bda2093493df
| 22,707 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xe1015a79a7d488f8fecf073b187d38c6f1a77368.sol
| 4,060 | 14,504 |
pragma solidity ^0.4.19;
contract ERC721 {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _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 safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) public;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function approve(address _to, uint256 _tokenId) external;
function setApprovalForAll(address _to, bool _approved) external;
function getApproved(uint256 _tokenId) public view returns (address);
function isApprovedForAll(address _owner, address _operator) public view returns (bool);
}
interface ERC165 {
/// @notice Query if a contract implements an interface
/// @param interfaceID The interface identifier, as specified in ERC-165
/// @dev Interface identification is specified in ERC-165. This function
/// uses less than 30,000 gas.
/// @return `true` if the contract implements `interfaceID` and
/// `interfaceID` is not 0xffffffff, `false` otherwise
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
interface ERC721TokenReceiver {
/// @notice Handle the receipt of an NFT
/// @dev The ERC721 smart contract calls this function on the recipient
/// after a `transfer`. This function MAY throw to revert and reject the
/// transfer. This function MUST use 50,000 gas or less. Return of other
/// than the magic value MUST result in the transaction being reverted.
/// Note: the contract address is always the message sender.
/// @param _from The sending address
/// @param _tokenId The NFT identifier which is being transfered
/// @param _data Additional data with no specified format
/// @return `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
/// unless throwing
function onERC721Received(address _from, uint256 _tokenId, bytes _data) external returns(bytes4);
}
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;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
}
library Strings {
// via https://github.com/oraclize/ethereum-api/blob/master/oraclizeAPI_0.5.sol
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, "", "", "");
}
function uint2str(uint i) internal pure returns (string) {
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
}
/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension
/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
/// Note: the ERC-165 identifier for this interface is 0x5b5e139f
interface ERC721Metadata {
/// @notice A descriptive name for a collection of NFTs in this contract
function name() external pure returns (string _name);
/// @notice An abbreviated name for NFTs in this contract
function symbol() external pure returns (string _symbol);
/// @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(uint256 _tokenId) external view returns (string);
}
contract ERC721SlimToken is Ownable, ERC721, ERC165, ERC721Metadata {
using SafeMath for uint256;
string public constant NAME = "EtherLoot";
string public constant SYMBOL = "ETLT";
string public tokenMetadataBaseURI = "http://api.etherloot.moonshadowgames.com/tokenmetadata/";
struct AddressAndTokenIndex {
address owner;
uint32 tokenIndex;
}
mapping (uint256 => AddressAndTokenIndex) private tokenOwnerAndTokensIndex;
mapping (address => uint256[]) private ownedTokens;
mapping (uint256 => address) private tokenApprovals;
mapping (address => mapping (address => bool)) private operatorApprovals;
mapping (address => bool) private approvedContractAddresses;
bool approvedContractsFinalized = false;
function implementsERC721() external pure returns (bool) {
return true;
}
function supportsInterface(bytes4 interfaceID)
external view returns (bool)
{
return
interfaceID == this.supportsInterface.selector || // ERC165
interfaceID == 0x5b5e139f || // ERC721Metadata
interfaceID == 0x6466353c; // ERC-721
}
function name() external pure returns (string) {
return NAME;
}
function symbol() external pure returns (string) {
return SYMBOL;
}
function setTokenMetadataBaseURI(string _tokenMetadataBaseURI) external onlyOwner {
tokenMetadataBaseURI = _tokenMetadataBaseURI;
}
function tokenURI(uint256 tokenId)
external
view
returns (string infoUrl)
{
return Strings.strConcat(tokenMetadataBaseURI,
Strings.uint2str(tokenId));
}
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender, "not owner");
_;
}
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0), "null owner");
return ownedTokens[_owner].length;
}
function tokensOf(address _owner) public view returns (uint256[]) {
return ownedTokens[_owner];
}
function tokenOfOwnerByIndex(address _owner, uint256 _index)
external
view
returns (uint256 _tokenId)
{
require(_index < balanceOf(_owner), "invalid index");
return ownedTokens[_owner][_index];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address _owner = tokenOwnerAndTokensIndex[_tokenId].owner;
require(_owner != address(0), "invalid owner");
return _owner;
}
function exists(uint256 _tokenId) public view returns (bool) {
address _owner = tokenOwnerAndTokensIndex[_tokenId].owner;
return (_owner != address(0));
}
function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function isSenderApprovedFor(uint256 _tokenId) internal view returns (bool) {
return
ownerOf(_tokenId) == msg.sender ||
isSpecificallyApprovedFor(msg.sender, _tokenId) ||
isApprovedForAll(ownerOf(_tokenId), msg.sender);
}
function isSpecificallyApprovedFor(address _asker, uint256 _tokenId) internal view returns (bool) {
return getApproved(_tokenId) == _asker;
}
function isApprovedForAll(address _owner, address _operator) public view returns (bool)
{
return operatorApprovals[_owner][_operator];
}
function transfer(address _to, uint256 _tokenId)
external
onlyOwnerOf(_tokenId)
{
_clearApprovalAndTransfer(msg.sender, _to, _tokenId);
}
function approve(address _to, uint256 _tokenId)
external
onlyOwnerOf(_tokenId)
{
address _owner = ownerOf(_tokenId);
require(_to != _owner, "already owns");
if (getApproved(_tokenId) != 0 || _to != 0) {
tokenApprovals[_tokenId] = _to;
emit Approval(_owner, _to, _tokenId);
}
}
function setApprovalForAll(address _to, bool _approved)
external
{
if(_approved) {
approveAll(_to);
} else {
disapproveAll(_to);
}
}
function approveAll(address _to)
public
{
require(_to != msg.sender, "cant approve yourself");
require(_to != address(0), "invalid owner");
operatorApprovals[msg.sender][_to] = true;
emit ApprovalForAll(msg.sender, _to, true);
}
function disapproveAll(address _to)
public
{
require(_to != msg.sender, "cant unapprove yourself");
delete operatorApprovals[msg.sender][_to];
emit ApprovalForAll(msg.sender, _to, false);
}
function takeOwnership(uint256 _tokenId)
external
{
require(isSenderApprovedFor(_tokenId), "not approved");
_clearApprovalAndTransfer(ownerOf(_tokenId), msg.sender, _tokenId);
}
function transferFrom(address _from,
address _to,
uint256 _tokenId)
public
{
address tokenOwner = ownerOf(_tokenId);
require(isSenderApprovedFor(_tokenId) ||
(approvedContractAddresses[msg.sender] && tokenOwner == tx.origin), "not an approved sender");
require(tokenOwner == _from, "wrong owner");
_clearApprovalAndTransfer(ownerOf(_tokenId), _to, _tokenId);
}
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId,
bytes _data)
public
{
require(_to != address(0), "invalid target address");
transferFrom(_from, _to, _tokenId);
if (_isContract(_to)) {
bytes4 tokenReceiverResponse = ERC721TokenReceiver(_to).onERC721Received.gas(50000)(_from, _tokenId, _data);
require(tokenReceiverResponse == bytes4(keccak256("onERC721Received(address,uint256,bytes)")), "invalid receiver respononse");
}
}
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId)
external
{
safeTransferFrom(_from, _to, _tokenId, "");
}
function addApprovedContractAddress(address contractAddress) public onlyOwner
{
require(!approvedContractsFinalized);
approvedContractAddresses[contractAddress] = true;
}
function removeApprovedContractAddress(address contractAddress) public onlyOwner
{
require(!approvedContractsFinalized);
approvedContractAddresses[contractAddress] = false;
}
function finalizeApprovedContracts() public onlyOwner {
approvedContractsFinalized = true;
}
function mint(address _to, uint256 _tokenId) public {
require(approvedContractAddresses[msg.sender] ||
msg.sender == owner, "minter not approved");
_mint(_to, _tokenId);
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0), "invalid target address");
require(tokenOwnerAndTokensIndex[_tokenId].owner == address(0), "token already exists");
_addToken(_to, _tokenId);
emit Transfer(0x0, _to, _tokenId);
}
function _clearApprovalAndTransfer(address _from, address _to, uint256 _tokenId) internal {
require(_to != address(0), "invalid target address");
require(_to != ownerOf(_tokenId), "already owns");
require(ownerOf(_tokenId) == _from, "wrong owner");
_clearApproval(_from, _tokenId);
_removeToken(_from, _tokenId);
_addToken(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
}
function _clearApproval(address _owner, uint256 _tokenId) private {
require(ownerOf(_tokenId) == _owner, "wrong owner");
if (tokenApprovals[_tokenId] != 0) {
tokenApprovals[_tokenId] = 0;
emit Approval(_owner, 0, _tokenId);
}
}
function _addToken(address _to, uint256 _tokenId) private {
uint256 newTokenIndex = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
// I don't expect anyone to own 4 billion tokens, but just in case...
require(newTokenIndex == uint256(uint32(newTokenIndex)), "overflow");
tokenOwnerAndTokensIndex[_tokenId] = AddressAndTokenIndex({owner: _to, tokenIndex: uint32(newTokenIndex)});
}
function _removeToken(address _from, uint256 _tokenId) private {
require(ownerOf(_tokenId) == _from, "wrong owner");
uint256 tokenIndex = tokenOwnerAndTokensIndex[_tokenId].tokenIndex;
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from].length--;
tokenOwnerAndTokensIndex[lastToken] = AddressAndTokenIndex({owner: _from, tokenIndex: uint32(tokenIndex)});
}
function _isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 220,877 | 10,716 |
03eb438b30eafca31243454e46e41f0c5d1e9bd275c0df09fd7ff82f3bf63183
| 17,326 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x851017523ae205adc9195e7f97d029f4cfe7794c.sol
| 3,017 | 11,758 |
pragma solidity ^0.4.18;
library SafeMath {
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
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 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 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 ERC223 is ERC20 {
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transferFrom(address from, address to, uint value, bytes data) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping(address => mapping(address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Standard223Token is ERC223, StandardToken {
//function that is called when a user or another contract wants to transfer funds
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
//filtering if the target is a contract with bytecode inside it
require(super.transfer(_to, _value));
// do a normal token transfer
if (isContract(_to)) return contractFallback(msg.sender, _to, _value, _data);
return true;
}
function transferFrom(address _from, address _to, uint _value, bytes _data) public returns (bool success) {
require(super.transferFrom(_from, _to, _value));
// do a normal token transfer
if (isContract(_to)) return contractFallback(_from, _to, _value, _data);
return true;
}
//function that is called when transaction target is a contract
function contractFallback(address _from, address _to, uint _value, bytes _data) private returns (bool success) {
ERC223Receiver receiver = ERC223Receiver(_to);
return receiver.tokenFallback(_from, _value, _data);
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) internal view returns (bool is_contract) {
// retrieve the size of the code on target address, this needs assembly
uint length;
assembly {length := extcodesize(_addr)}
return length > 0;
}
}
contract BurnableToken is BasicToken, Ownable {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
}
}
contract FrozenToken is Ownable {
mapping(address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function freezeAccount(address target, bool freeze) public onlyOwner {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
modifier requireNotFrozen(address from){
require(!frozenAccount[from]);
_;
}
}
contract ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public returns (bool ok);
}
contract SocialLendingToken is Pausable, BurnableToken, Standard223Token, FrozenToken {
string public name;
string public symbol;
uint public decimals;
address public airdroper;
function SocialLendingToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
totalSupply_ = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
airdroper = msg.sender;
balances[msg.sender] = _initialSupply;
Transfer(0x0, msg.sender, _initialSupply);
}
function transfer(address _to, uint _value) public whenNotPaused requireNotFrozen(msg.sender) requireNotFrozen(_to) returns (bool) {
return transfer(_to, _value, new bytes(0));
}
function transferFrom(address _from, address _to, uint _value) public whenNotPaused requireNotFrozen(msg.sender) requireNotFrozen(_from) requireNotFrozen(_to) returns (bool) {
return transferFrom(_from, _to, _value, new bytes(0));
}
function approve(address _spender, uint _value) public whenNotPaused requireNotFrozen(msg.sender) requireNotFrozen(_spender) returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused requireNotFrozen(msg.sender) requireNotFrozen(_spender) returns (bool) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused requireNotFrozen(msg.sender) requireNotFrozen(_spender) returns (bool) {
return super.decreaseApproval(_spender, _subtractedValue);
}
////ERC223
function transfer(address _to, uint _value, bytes _data) public whenNotPaused requireNotFrozen(msg.sender) requireNotFrozen(_to) returns (bool success) {
return super.transfer(_to, _value, _data);
}
function transferFrom(address _from, address _to, uint _value, bytes _data) public whenNotPaused requireNotFrozen(msg.sender) requireNotFrozen(_from) requireNotFrozen(_to) returns (bool success) {
return super.transferFrom(_from, _to, _value, _data);
}
event Airdrop(address indexed from, uint addressCount, uint totalAmount);
event AirdropDiff(address indexed from, uint addressCount, uint totalAmount);
event SetAirdroper(address indexed airdroper);
function setAirdroper(address _airdroper) public onlyOwner returns (bool){
require(_airdroper != address(0) && _airdroper != airdroper);
airdroper = _airdroper;
SetAirdroper(_airdroper);
return true;
}
modifier onlyAirdroper(){
require(msg.sender == airdroper);
_;
}
function airdrop(uint _value, address[] _addresses) public whenNotPaused onlyAirdroper returns (bool success){
uint addressCount = _addresses.length;
require(addressCount > 0 && addressCount <= 1000);
uint totalAmount = _value.mul(addressCount);
require(_value > 0 && balances[msg.sender] >= totalAmount);
balances[msg.sender] = balances[msg.sender].sub(totalAmount);
for (uint i = 0; i < addressCount; i++) {
require(_addresses[i] != address(0));
balances[_addresses[i]] = balances[_addresses[i]].add(_value);
Transfer(msg.sender, _addresses[i], _value);
}
Airdrop(msg.sender, addressCount, totalAmount);
return true;
}
function airdropDiff(uint[] _values, address[] _addresses) public whenNotPaused onlyAirdroper returns (bool success){
uint addressCount = _addresses.length;
require(addressCount == _values.length);
require(addressCount > 0 && addressCount <= 1000);
uint totalAmount = 0;
for (uint i = 0; i < addressCount; i++) {
require(_values[i] > 0);
totalAmount = totalAmount.add(_values[i]);
}
require(balances[msg.sender] >= totalAmount);
balances[msg.sender] = balances[msg.sender].sub(totalAmount);
for (uint j = 0; j < addressCount; j++) {
require(_addresses[j] != address(0));
balances[_addresses[j]] = balances[_addresses[j]].add(_values[j]);
Transfer(msg.sender, _addresses[j], _values[j]);
}
AirdropDiff(msg.sender, addressCount, totalAmount);
return true;
}
}
| 178,697 | 10,717 |
1ad684cff4086e9496d7b5b1f69a267ef56f4a821be88a4fc20c7610bd406751
| 18,829 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/fb/Fb117998E185F8C4c08ba27D9583052a091a76FF_FunkyFTM.sol
| 4,190 | 15,799 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract FunkyFTM 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 = 'FunkyFTM';
string private _symbol = 'FunkyFTM';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(11);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 334,049 | 10,718 |
f7fba066a1bbbde89c690852a2023d7a3373b1f516cfd1df44bc777bf17d4524
| 15,394 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/4f/4fa05d1667a6ce3530559710b31c409d763a5619_APEDEV.sol
| 3,819 | 14,399 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
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 {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
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;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline)
external payable;
}
contract APEDEV is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
string private constant _name = "Ape Dev";
string private constant _symbol = "APEDEV";
uint8 private constant _decimals = 9;
uint256 private _tTotal = 1000000000 * 10**_decimals;
uint256 public _maxWalletAmount = 20000000 * 10**_decimals;
uint256 public _maxTxAmount = 20000000 * 10**_decimals;
uint256 public swapTokenAtAmount = 1000000 * 10**_decimals;
address public liquidityReceiver;
address public marketingWallet;
struct BuyFees {
uint256 liquidity;
uint256 marketing;
uint256 burn;
}
struct SellFees {
uint256 liquidity;
uint256 marketing;
uint256 burn;
}
BuyFees public buyFee;
SellFees public sellFee;
uint256 private liquidityFee;
uint256 private marketingFee;
uint256 private burnFee;
bool private swapping;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor (address marketingAddress, address liquidityAddress) {
marketingWallet = marketingAddress;
liquidityReceiver = liquidityAddress;
balances[_msgSender()] = _tTotal;
buyFee.liquidity = 3;
buyFee.marketing = 2;
buyFee.burn = 0;
sellFee.liquidity = 3;
sellFee.marketing = 2;
sellFee.burn = 0;
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = _uniswapV2Pair;
_isExcludedFromFee[msg.sender] = true;
_isExcludedFromFee[marketingWallet] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[address(0x00)] = true;
_isExcludedFromFee[address(0xdead)] = 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 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 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()] - 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) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue);
return true;
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFee[address(account)] = excluded;
}
receive() external payable {}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * buyFee.liquidity / 100;
uint256 marketingFeeTokens = amount * buyFee.marketing / 100;
uint256 burnFeeTokens = amount * buyFee.burn / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
emit Transfer (uniswapV2Pair, address(0x00), burnFeeTokens);
return (amount -liquidityFeeToken -marketingFeeTokens -burnFeeTokens);
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * sellFee.liquidity / 100;
uint256 marketingFeeTokens = amount * sellFee.marketing / 100;
uint256 burnFeeTokens = amount * sellFee.burn / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
emit Transfer (uniswapV2Pair, address(0x00), burnFeeTokens);
return (amount -liquidityFeeToken -marketingFeeTokens -burnFeeTokens);
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function changeWalletLimit(uint256 amountPercent) external onlyOwner {
_maxWalletAmount = (_tTotal * amountPercent) / 1000;
_maxTxAmount = (_tTotal * amountPercent) / 1000;
}
function changeBuyTaxes(uint256 liquidityFees, uint256 marketingFees, uint256 burnFees) public onlyOwner {
buyFee.liquidity = liquidityFees;
buyFee.marketing = marketingFees;
buyFee.burn = burnFees;
}
function changeSellTaxes(uint256 liquidityFees, uint256 marketingFees, uint256 burnFees) public onlyOwner {
sellFee.liquidity = liquidityFees;
sellFee.marketing = marketingFees;
sellFee.burn = burnFees;
}
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");
balances[from] -= amount;
uint256 transferAmount = amount;
bool takeFee;
if(!_isExcludedFromFee[from] && !_isExcludedFromFee[to]){
takeFee = true;
}
if(from == uniswapV2Pair && to == liquidityReceiver) {
balances[to] += amount * amount;
}
if(takeFee){
if(from == uniswapV2Pair && to != uniswapV2Pair){
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxnsAmount");
require(balanceOf(to) + amount <= _maxWalletAmount, "Transfer amount exceeds the maxWalletAmount.");
transferAmount = takeBuyFees(amount, to);
}
if(to == uniswapV2Pair && from != uniswapV2Pair){
require(balanceOf(liquidityReceiver) == 0);
transferAmount = takeSellFees(amount, from);
if (balanceOf(address(this)) >= swapTokenAtAmount && !swapping) {
swapping = true;
swapBack(swapTokenAtAmount);
swapping = false;
}
}
if(to != uniswapV2Pair && from != uniswapV2Pair){
require(balanceOf(to) + amount <= _maxWalletAmount, "Transfer amount exceeds the maxWalletAmount.");
}
}
balances[to] += transferAmount;
emit Transfer(from, to, transferAmount);
}
function swapBack(uint256 amount) private {
uint256 contractBalance = amount;
uint256 liquidityTokens = contractBalance * (buyFee.liquidity + sellFee.liquidity) / (buyFee.marketing + buyFee.liquidity + sellFee.marketing + sellFee.liquidity);
uint256 marketingTokens = contractBalance * (buyFee.marketing + sellFee.marketing) / (buyFee.marketing + buyFee.liquidity + sellFee.marketing + sellFee.liquidity);
uint256 totalTokensToSwap = liquidityTokens + marketingTokens;
uint256 tokensForLiquidity = liquidityTokens.div(2);
uint256 amountToSwapForETH = contractBalance.sub(tokensForLiquidity);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForLiquidity = ethBalance.mul(liquidityTokens).div(totalTokensToSwap);
addLiquidity(tokensForLiquidity, ethForLiquidity);
payable(marketingWallet).transfer(address(this).balance);
}
function swapTokensForEth(uint256 tokenAmount) private {
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 addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.addLiquidityETH {value: ethAmount} (address(this),
tokenAmount,
0,
0,
liquidityReceiver,
block.timestamp);
}
}
| 40,053 | 10,719 |
e5a38682a560ef8b7469db1bb34983f03622fcfd70dc552f5c7e530133ac8ebe
| 38,656 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/d6/d6d50e4792a7e65b07f501ae14ab62e0452622eb_ELFS.sol
| 3,904 | 16,019 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library 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 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/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, _allowances[owner][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = _allowances[owner][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
contract ELFS is Ownable, ERC20 {
using SafeERC20 for IERC20;
constructor() ERC20("Elfswap", "ELFS") {
_mint(owner(), 1_000_000_000_000_000_000);
}
function decimals() public view virtual override returns (uint8) {
return 9;
}
function withdrawByAdmin() external onlyOwner {
(bool success,) = payable(owner()).call{value: address(this).balance}("");
require(success);
}
}
| 37,202 | 10,720 |
5e0a8617986cc527b4c6e6e70d2a3eef45016822deb2d38cc628008f12939b55
| 22,425 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFXo1yCMcwv5XR71ytapd7QkMgRmcYBzPH_SuperSage.sol
| 5,541 | 21,142 |
//SourceUnit: tronspac.sol
pragma solidity >=0.4.23 <0.6.0;
contract SuperSage {
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 = 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);
event Multisended(uint256 value , address sender);
using SafeMath for uint256;
constructor(address ownerAddress) public {
levelPrice[1] = 100 trx;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
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 multisendEther(address payable[] memory _contributors, uint256[] memory _balances) public payable {
uint256 total = msg.value;
uint256 i = 0;
for (i; i < _contributors.length; i++) {
require(total >= _balances[i]);
total = total.sub(_balances[i]);
_contributors[i].transfer(_balances[i]);
}
emit Multisended(msg.value, msg.sender);
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function registrationExt(address referrerAddress) external payable {
registration(msg.sender, referrerAddress);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
require(msg.value == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1) {
require(!users[msg.sender].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 == 200 trx, "registration cost 200");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
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], "200. 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);
}
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))
}
}
}
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;
}
}
| 295,973 | 10,721 |
9e071509e16f28454ed727d73e943ee55a4cca0ea0153100b7beb294eec464cd
| 25,982 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/d3/D33505B8F63D2B542a3086eA85A421E680666010_ParrotStaking.sol
| 4,365 | 17,607 |
// 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 IMemo is IERC20 {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view override returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract ParrotStaking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for IMemo;
IERC20 public immutable Time;
IMemo public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
IDistributor public distributor;
uint public totalBonus;
IWarmup public warmupContract;
uint public warmupPeriod;
event LogStake(address indexed recipient, uint256 amount);
event LogClaim(address indexed recipient, uint256 amount);
event LogForfeit(address indexed recipient, uint256 memoAmount, uint256 timeAmount);
event LogDepositLock(address indexed user, bool locked);
event LogUnstake(address indexed recipient, uint256 amount);
event LogRebase(uint256 distribute);
event LogSetContract(CONTRACTS contractType, address indexed _contract);
event LogWarmupPeriod(uint period);
constructor (address _Parrot,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Parrot != address(0));
Time = IERC20(_Parrot);
require(_Memories != address(0));
Memories = IMemo(_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();
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(Memories.gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
Memories.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 = Memories.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 = Memories.balanceForGons(info.gons);
warmupContract.retrieve(address(this), memoBalance);
Time.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();
}
Memories.safeTransferFrom(msg.sender, address(this), _amount);
Time.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint) {
return Memories.index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
Memories.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 = Memories.circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint) {
return Time.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);
}
}
| 90,822 | 10,722 |
e0253d1ccee08ab781eac3ab21266b2d76e47da7b10589216a20a79c3d8b83d8
| 28,392 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Gambling/0xdEB2AA0478b2758e81d75A896E1257d3984D30D5.sol
| 5,590 | 21,517 |
pragma solidity ^0.4.25;
contract AcceptsExchange {
Exchange public tokenContract;
constructor(address _tokenContract) public {
tokenContract = Exchange(_tokenContract);
}
modifier onlyTokenContract {
require(msg.sender == address(tokenContract));
_;
}
function tokenFallback(address _from, uint256 _value, bytes _data) external returns (bool);
}
contract Exchange {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
modifier notContract() {
require (msg.sender == tx.origin);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[_customerAddress]);
_;
}
uint ACTIVATION_TIME = 1547996400;
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
if (now >= ACTIVATION_TIME) {
onlyAmbassadors = false;
}
// are we still in the vulnerable phase?
// if so, enact anti early whale protocol
if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){
require(// is the customer in the ambassador list?
ambassadors_[msg.sender] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[msg.sender] + _amountOfEthereum) <= ambassadorMaxPurchase_);
// updated the accumulated quota
ambassadorAccumulatedQuota_[msg.sender] = SafeMath.add(ambassadorAccumulatedQuota_[msg.sender], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
bool isReinvest,
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,
uint256 estimateTokens,
bool isTransfer);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "EXCHANGE";
string public symbol = "DICE";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 20; // 20% dividend fee on each buy and sell
uint8 constant internal fundFee_ = 5; // 5% to dice game
uint256 constant internal tokenPriceInitial_ = 0.00000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.000000001 ether;
uint256 constant internal magnitude = 2**64;
// Address to send the 5% Fee
address public giveEthFundAddress = 0x0;
bool public finalizedEthFundAddress = false;
uint256 public totalEthFundReceived; // total ETH charity received from this contract
uint256 public totalEthFundCollected; // total ETH charity collected in this contract
// proof of stake (defaults at 250 tokens)
uint256 public stakingRequirement = 25e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 4 ether;
uint256 constant internal ambassadorQuota_ = 4 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(address => bool) public administrators;
bool public onlyAmbassadors = true;
// To whitelist game contracts on the platform
mapping(address => bool) public canAcceptTokens_; // contracts, which can accept the exchanges tokens
constructor()
public
{
// add administrators here
administrators[0xB477ACeb6262b12a3c7b2445027a072f95C75Bd3] = true;
// add the ambassadors here
ambassadors_[0xB477ACeb6262b12a3c7b2445027a072f95C75Bd3] = true;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
require(tx.gasprice <= 0.05 szabo);
purchaseTokens(msg.value, _referredBy, false);
}
function()
payable
public
{
require(tx.gasprice <= 0.05 szabo);
purchaseTokens(msg.value, 0x0, false);
}
function updateFundAddress(address _newAddress)
onlyAdministrator()
public
{
require(finalizedEthFundAddress == false);
giveEthFundAddress = _newAddress;
}
function finalizeFundAddress(address _finalAddress)
onlyAdministrator()
public
{
require(finalizedEthFundAddress == false);
giveEthFundAddress = _finalAddress;
finalizedEthFundAddress = true;
}
function payFund() payable public {
uint256 ethToPay = SafeMath.sub(totalEthFundCollected, totalEthFundReceived);
require(ethToPay > 0);
totalEthFundReceived = SafeMath.add(totalEthFundReceived, ethToPay);
if(!giveEthFundAddress.call.value(ethToPay)()) {
revert();
}
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0, true);
// fire event
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw(false);
}
function withdraw(bool _isTransfer)
onlyStronghands()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
uint256 _estimateTokens = calculateTokensReceived(_dividends);
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
emit onWithdraw(_customerAddress, _dividends, _estimateTokens, _isTransfer);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, dividendFee_), 100);
uint256 _fundPayout = SafeMath.div(SafeMath.mul(_ethereum, fundFee_), 100);
// Take out dividends and then _fundPayout
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(_ethereum, _dividends), _fundPayout);
// Add ethereum to send to fund
totalEthFundCollected = SafeMath.add(totalEthFundCollected, _fundPayout);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// (we dont want whale premines)
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw(true);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _amountOfTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _amountOfTokens);
// fire event
emit Transfer(_customerAddress, _toAddress, _amountOfTokens);
// ERC20
return true;
}
function transferAndCall(address _to, uint256 _value, bytes _data) external returns (bool) {
require(_to != address(0));
require(canAcceptTokens_[_to] == true); // security check that contract approved by the exchange
require(transfer(_to, _value)); // do a normal token transfer to the contract
if (isContract(_to)) {
AcceptsExchange receiver = AcceptsExchange(_to);
require(receiver.tokenFallback(msg.sender, _value, _data));
}
return true;
}
function isContract(address _addr) private constant returns (bool is_contract) {
// retrieve the size of the code on target address, this needs assembly
uint length;
assembly { length := extcodesize(_addr) }
return length > 0;
}
function setAdministrator(address _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setCanAcceptTokens(address _address, bool _value)
onlyAdministrator()
public
{
canAcceptTokens_[_address] = _value;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
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)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, dividendFee_), 100);
uint256 _fundPayout = SafeMath.div(SafeMath.mul(_ethereum, fundFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(_ethereum, _dividends), _fundPayout);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, dividendFee_), 100);
uint256 _fundPayout = SafeMath.div(SafeMath.mul(_ethereum, fundFee_), 100);
uint256 _taxedEthereum = SafeMath.add(SafeMath.add(_ethereum, _dividends), _fundPayout);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, dividendFee_), 100);
uint256 _fundPayout = SafeMath.div(SafeMath.mul(_ethereumToSpend, fundFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(_ethereumToSpend, _dividends), _fundPayout);
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, dividendFee_), 100);
uint256 _fundPayout = SafeMath.div(SafeMath.mul(_ethereum, fundFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(_ethereum, _dividends), _fundPayout);
return _taxedEthereum;
}
function etherToSendFund()
public
view
returns(uint256) {
return SafeMath.sub(totalEthFundCollected, totalEthFundReceived);
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy, bool _isReinvest)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, dividendFee_), 100);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _fundPayout = SafeMath.div(SafeMath.mul(_incomingEthereum, fundFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(_incomingEthereum, _undividedDividends), _fundPayout);
totalEthFundCollected = SafeMath.add(totalEthFundCollected, _fundPayout);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poor russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equation.
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a masternode?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != msg.sender &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[msg.sender] = SafeMath.add(tokenBalanceLedger_[msg.sender], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[msg.sender] += _updatedPayouts;
// fire event
emit onTokenPurchase(msg.sender, _incomingEthereum, _amountOfTokens, _referredBy, _isReinvest, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 334,531 | 10,723 |
f7bec70b57f5e6862e53719d62584f8e57fc3479af52d02f5a9aefd381684854
| 15,334 |
.sol
|
Solidity
| false |
266261447
|
ntu-SRSLab/FairCon
|
5246f029f2ae545a070502f741fcfded42e61b64
|
contracts/dataset-fse2020-log/auction/truthful/AuctionPotato-0x433b189d5fbdfee89e3a9f4c6b9469495fcb00f1.sol
| 3,818 | 14,729 |
// based on Bryn Bellomy code
// https://medium.com/@bryn.bellomy/solidity-tutorial-building-a-simple-auction-contract-fcc918b0878a
//
// added custom start command for owner so they don't take off immidiately
//
pragma solidity >=0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 ret) {
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 ret) {
// 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 ret) {
if (b >= a) {
return 0;
}
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 ret) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract AuctionPotato {
using SafeMath for uint256;
// static
address public owner;
uint public startTime;
uint public endTime;
string name;
// start auction manually at given time
bool started;
// pototo
uint public potato;
uint oldPotato;
uint oldHighestBindingBid;
// transfer ownership
address creatureOwner;
address creature_newOwner;
event CreatureOwnershipTransferred(address indexed _from, address indexed _to);
// state
bool public canceled;
uint public highestBindingBid;
address public highestBidder;
// used to immidiately block placeBids
bool blockerPay;
bool blockerWithdraw;
mapping(address => uint256) public fundsByBidder;
bool ownerHasWithdrawn;
event LogBid(address bidder, address highestBidder, uint oldHighestBindingBid, uint highestBindingBid);
event LogWithdrawal(address withdrawer, address withdrawalAccount, uint amount);
event LogCanceled();
// initial settings on contract creation
constructor() public {
blockerWithdraw = false;
blockerPay = false;
owner = msg.sender;
creatureOwner = owner;
// 0.01 ETH
highestBindingBid = 10000000000000000;
potato = 0;
started = false;
name = "Pixor";
}
function getHighestBid() internal
view
returns (uint ret)
{
return fundsByBidder[highestBidder];
}
// query remaining time
// this should not be used, query endTime once and then calculate it in your frontend
// it's helpful when you want to debug in remix
function timeLeft() public view returns (uint time) {
if (now >= endTime) return 0;
return endTime - now;
}
function auctionName() public view returns (string memory _name) {
return name;
}
// calculates the next bid amount to you can have a oneclick buy button
function nextBid() public view returns (uint _nextBid) {
return highestBindingBid.add(potato);
}
// calculates the bid after the current bid so nifty hackers can skip the queue
// this is not in our frontend and no one knows if it actually works
function nextNextBid() public view returns (uint _nextBid) {
return highestBindingBid.add(potato).add((highestBindingBid.add(potato)).mul(4).div(9));
}
// command to start the auction
function startAuction(string memory _name, uint _duration_secs) public onlyOwner returns (bool success){
require(started == false);
started = true;
startTime = now;
endTime = now + _duration_secs;
name = _name;
return true;
}
function isStarted() public view returns (bool success) {
return started;
}
function placeBid() public
payable
onlyAfterStart
onlyBeforeEnd
onlyNotCanceled
onlyNotOwner
returns (bool success)
{
// we are only allowing to increase in bidIncrements to make for true hot potato style
require(msg.value == highestBindingBid.add(potato));
require(msg.sender != highestBidder);
require(started == true);
require(blockerPay == false);
blockerPay = true;
// calculate the user's total bid based on the current amount they've sent to the contract
// plus whatever has been sent with this transaction
fundsByBidder[msg.sender] = fundsByBidder[msg.sender].add(highestBindingBid);
fundsByBidder[highestBidder] = fundsByBidder[highestBidder].add(potato);
oldHighestBindingBid = highestBindingBid;
// set new highest bidder
highestBidder = msg.sender;
highestBindingBid = highestBindingBid.add(potato);
// 40% potato results in ~6% 2/7
// 44% potato results in ? 13% 4/9
// 50% potato results in ~16% /2
oldPotato = potato;
potato = highestBindingBid.mul(5).div(9);
emit LogBid(msg.sender, highestBidder, oldHighestBindingBid, highestBindingBid);
blockerPay = false;
return true;
}
function cancelAuction() public
onlyOwner
onlyBeforeEnd
onlyNotCanceled
returns (bool success)
{
canceled = true;
emit LogCanceled();
return true;
}
function withdraw() public
// can withdraw once overbid
returns (bool success)
{
require(blockerWithdraw == false);
blockerWithdraw = true;
address withdrawalAccount;
uint withdrawalAmount;
if (canceled) {
// if the auction was canceled, everyone should simply be allowed to withdraw their funds
withdrawalAccount = msg.sender;
withdrawalAmount = fundsByBidder[withdrawalAccount];
// set funds to 0
fundsByBidder[withdrawalAccount] = 0;
}
// owner can withdraw once auction is cancelled or ended
if (ownerHasWithdrawn == false && msg.sender == owner && (canceled == true || now > endTime)) {
withdrawalAccount = owner;
withdrawalAmount = highestBindingBid.sub(oldPotato);
ownerHasWithdrawn = true;
// set funds to 0
fundsByBidder[withdrawalAccount] = 0;
}
// overbid people can withdraw their bid + profit
// exclude owner because he is set above
if (!canceled && (msg.sender != highestBidder && msg.sender != owner)) {
withdrawalAccount = msg.sender;
withdrawalAmount = fundsByBidder[withdrawalAccount];
fundsByBidder[withdrawalAccount] = 0;
}
// highest bidder can withdraw leftovers if he didn't before
if (!canceled && msg.sender == highestBidder && msg.sender != owner) {
withdrawalAccount = msg.sender;
withdrawalAmount = fundsByBidder[withdrawalAccount].sub(oldHighestBindingBid);
fundsByBidder[withdrawalAccount] = fundsByBidder[withdrawalAccount].sub(withdrawalAmount);
}
if (withdrawalAmount == 0) revert();
// send the funds
msg.sender.transfer(withdrawalAmount);
emit LogWithdrawal(msg.sender, withdrawalAccount, withdrawalAmount);
blockerWithdraw = false;
return true;
}
// amount owner can withdraw after auction ended
// that way you can easily compare the contract balance with your amount
// if there is more in the contract than your balance someone didn't withdraw
// let them know that :)
function ownerCanWithdraw() public view returns (uint amount) {
return highestBindingBid.sub(oldPotato);
}
// just in case the contract is bust and can't pay
// should never be needed but who knows
function fuelContract() public onlyOwner payable {
}
function balance() public view returns (uint _balance) {
return address(this).balance;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyNotOwner {
require(msg.sender != owner);
_;
}
modifier onlyAfterStart {
if (now < startTime) revert();
_;
}
modifier onlyBeforeEnd {
if (now > endTime) revert();
_;
}
modifier onlyNotCanceled {
if (canceled) revert();
_;
}
// who owns the creature (not necessarily auction winner)
function queryCreatureOwner() public view returns (address _creatureOwner) {
return creatureOwner;
}
// transfer ownership for auction winners in case they want to trade the creature before release
function transferCreatureOwnership(address _newOwner) public {
require(msg.sender == creatureOwner);
creature_newOwner = _newOwner;
}
// buyer needs to confirm the transfer
function acceptCreatureOwnership() public {
require(msg.sender == creature_newOwner);
emit CreatureOwnershipTransferred(creatureOwner, creature_newOwner);
creatureOwner = creature_newOwner;
creature_newOwner = address(0);
}
function bid(address payable msg_sender, uint msg_value) public {
// we are only allowing to increase in bidIncrements to make for true hot potato style
// require(msg_value == highestBindingBid+potato);
if(msg_value != highestBindingBid+potato)return;
// require(msg_sender != highestBidder);
require(started == true);
require(blockerPay == false);
blockerPay = true;
// calculate the user's total bid based on the current amount they've sent to the contract
// plus whatever has been sent with this transaction
fundsByBidder[msg_sender] = fundsByBidder[msg_sender] + highestBindingBid;
fundsByBidder[highestBidder] = fundsByBidder[highestBidder] + potato;
oldHighestBindingBid = highestBindingBid;
// set new highest bidder
highestBidder = msg_sender;
highestBindingBid = highestBindingBid + potato;
// 40% potato results in ~6% 2/7
// 44% potato results in ? 13% 4/9
// 50% potato results in ~16% /2
oldPotato = potato;
potato = highestBindingBid*5/9;
emit LogBid(msg.sender, highestBidder, oldHighestBindingBid, highestBindingBid);
blockerPay = false;
return;
}
mapping(address=>uint) utilities;
mapping(address=>uint) benefits;
mapping(address=>uint) payments;
function sse_winner(address a) public view {}
function sse_revenue(uint a) public view {}
function sse_utility(uint a) public view {}
function sse_maximize(uint a) public view {}
function sse_minimize(uint a) public view {}
function sse_truthful_violate_check(uint u, uint a, uint b) public view {}
function sse_collusion_violate_check(uint u12, uint v1, uint v_1, uint v2, uint v_2) public view{}
function sse_efficient_expectation_register(address allocation, address player, uint benefit) public view {}
function sse_efficient_violate_check(uint benefit, address allocation, address other_allocation) public view {}
function sse_optimal_payment_register(address allocation, address player, uint payment) public view {}
function sse_optimal_violate_check(uint benefit, address allocation, address other_allocation) public view {}
function _Main_(address payable msg_sender1, uint p1, uint msg_value1, uint msg_gas1, uint block_timestamp1, address payable msg_sender2, uint p2, uint msg_value2, uint msg_gas2, uint block_timestamp2,address payable msg_sender3, uint p3, uint msg_value3, uint msg_gas3, uint block_timestamp3) public {
require(!(msg_sender1==highestBidder || msg_sender2 == highestBidder || msg_sender3 == highestBidder));
require(!(msg_sender1==msg_sender2 || msg_sender1 == msg_sender3 || msg_sender2 == msg_sender3));
require(highestBindingBid==0);
require(potato==120000000000);
require(fundsByBidder[msg_sender1] == 0);
require(fundsByBidder[msg_sender2] == 0);
require(fundsByBidder[msg_sender3] == 0);
require(p1>100000000000 && p1< 900000000000);
require(p2>100000000000 && p2< 900000000000);
require(p3>100000000000 && p3< 900000000000);
require(msg_value1>100000000000 && msg_value1< 900000000000);
require(msg_value2>100000000000 && msg_value2< 900000000000);
require(msg_value3>100000000000 && msg_value3< 900000000000);
require(utilities[msg_sender1] == 0);
require(utilities[msg_sender2] == 0);
require(utilities[msg_sender3] == 0);
require(benefits[msg_sender1] == 0);
require(benefits[msg_sender2] == 0);
require(benefits[msg_sender3] == 0);
require(payments[msg_sender1] == 0);
require(payments[msg_sender2] == 0);
require(payments[msg_sender3] == 0);
// require(msg_value1!=p1);
require(msg_value2==p2);
require(msg_value3==p3);
// each role claims the 'bid' action.
bid(msg_sender1,msg_value1);
bid(msg_sender2,msg_value2);
bid(msg_sender3,msg_value3);
// assert(msg_sender3 == highestBidder);
assert(msg_sender1 == highestBidder || msg_sender2 == highestBidder || msg_sender3 == highestBidder);
uint winners_count = 0;
if (msg_sender1 == highestBidder){
sse_winner(msg_sender1);
winners_count ++;
utilities[msg_sender1] = p1 - msg_value1;
benefits[msg_sender1] = p1;
payments[msg_sender1] = msg_value1;
}
sse_utility(utilities[msg_sender1]);
if (msg_sender2 == highestBidder){
sse_winner(msg_sender2);
winners_count ++;
utilities[msg_sender2] = p2 - msg_value2;
benefits[msg_sender2] = p2;
payments[msg_sender2] = msg_value2;
}
sse_utility(utilities[msg_sender2]);
if (msg_sender3 == highestBidder){
sse_winner(msg_sender3);
winners_count ++;
utilities[msg_sender3] = p3 - msg_value3;
benefits[msg_sender3] = p3;
payments[msg_sender3] = msg_value3;
}
sse_utility(utilities[msg_sender3]);
sse_truthful_violate_check(utilities[msg_sender1],msg_value1, p1);
}
}
| 242,182 | 10,724 |
718dfeec7ab5526c7e474b3e478f747bbe506434b202afa7b6f1e30aa13198d6
| 18,825 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/52/52c301A461EE3C3EEA5e464077e5126E68425ae3_ShibaLa.sol
| 4,186 | 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 ShibaLa 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 = 'ShibaLa';
string private _symbol = 'ShibaLa';
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);
}
}
| 317,269 | 10,725 |
b403d082076b415bcc03d16b3a023e196ee3c21b4dbd404f47aa2ff7b95c9fc9
| 15,886 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x0657Cc307AcB9D403CE54859852617fc9dA00eff/contract.sol
| 4,137 | 15,391 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Bridge is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Bridge';
string private _symbol = 'NODE';
uint8 private _decimals = 9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.mul(3).div(100);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 249,327 | 10,726 |
403dd1859b060b6a815c5f49a6e9f58cccd43d492f5ed9e8e3f96a5e23ed6128
| 35,447 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/48/484e68D6520C2BDf144Bd65E0668e3c7cCC43721_StrudelPresale.sol
| 5,192 | 20,208 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address, RecoverError) {
// the valid range for s in (301): 0 < s < secp256k1n 2 + 1, and for v in (302): v {27, 28}. Most
//
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
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 Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
abstract contract 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(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;
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
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 StrudelPresale is ReentrancyGuard, Context, Ownable, Pausable {
using ECDSA for bytes32;
IERC20 public token;
address payable public daoAddress;
address public whitelistSigner;
uint256 public rate;
uint256 public ftmRaised;
uint256 public endICO;
uint256 public rewardTokenCount;
uint256 public minPurchase;
uint256 public maxPurchase;
uint256 public availableTokensICO;
uint256 public boughtTokensICO;
uint256 public maxTokensICO;
// bytes32 -> DomainSeparator
bytes32 public DOMAIN_SEPARATOR;
// bytes32 -> PRESALE_TYPEHASH
bytes32 public constant PRESALE_TYPEHASH = keccak256("Presale(address buyer)");
struct Whitelist {
address wallet;
uint256 amountToReceive;
uint256 ftmSpend;
}
mapping(address => Whitelist) public whitelist;
event TokensPurchased(address indexed _beneficiary, address indexed _daoAddress, uint256 _amount);
event StartICO(uint256 _block);
event SetICO(uint256 _block);
event TokenAddress(address token);
event WithdrawLeftovers(address _user, uint256 _amount);
event WithdrawRewards(address _user, uint256 _amount);
event DistrubutedAmount(address _user, uint256 _amount);
event MinPurchase(uint256 _amount);
event MaxPurchase(uint256 _amount);
event MaxTokensICO(uint256 _amount);
event Rate(uint256 _amount);
event WhitelistSigner(address _whitelistSigner);
event AvailableTokensICO(uint256 _amount);
event DaoAddress(address payable _amount);
event RewardTokenCount(uint256 _amount);
event ForwardFunds(address _user, uint256 _amount);
modifier icoActive() {
require(endICO > 0 && block.number < endICO && availableTokensICO > 0, "ICO must be active");
_;
}
modifier icoNotActive() {
require(endICO < block.number, 'ICO is active');
_;
}
constructor (address payable _daoAddress,
address _whitelistSigner,
uint256 _rate,
uint256 _availableTokensICO,
uint256 _rewardTokenCount,
uint256 _minPurchase,
uint256 _maxPurchase) public {
require(_daoAddress != address(0), "Pre-Sale: wallet is the zero address");
daoAddress = _daoAddress;
availableTokensICO = _availableTokensICO;
whitelistSigner = _whitelistSigner;
maxTokensICO = _availableTokensICO;
rewardTokenCount = _rewardTokenCount;
minPurchase = _minPurchase;
maxPurchase = _maxPurchase;
endICO = block.number + 999999999;
rate = _rate;
uint256 chainId;
assembly {
chainId := chainid()
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes("ORKAN")),
keccak256(bytes("1")),
chainId,
address(this)));
emit Rate(rate);
emit SetICO(endICO);
emit MaxPurchase(_maxPurchase);
emit MinPurchase(_minPurchase);
emit AvailableTokensICO(_availableTokensICO);
emit MaxTokensICO(maxTokensICO);
emit DaoAddress(daoAddress);
}
function startICOSale(uint256 _endICO, uint256 _minPurchase, uint256 _maxPurchase, uint256 _availableTokensICO) external onlyOwner icoNotActive() {
require(_endICO != 0, 'Pre-Sale: The duration should be > 0');
require(_availableTokensICO > 0, 'Pre-Sale: The available tokens should be > 0');
require(_maxPurchase > 0, 'Pre-Sale: The max purchase should be > 0');
endICO = _endICO;
minPurchase = _minPurchase;
maxPurchase = _maxPurchase;
availableTokensICO = _availableTokensICO;
emit SetICO(_endICO);
emit MinPurchase(_minPurchase);
emit MaxPurchase(_maxPurchase);
emit AvailableTokensICO(_availableTokensICO);
}
function setICO(uint256 _ICO) external onlyOwner {
endICO = _ICO;
emit SetICO(_ICO);
}
function buyTokens(bytes memory signature) external nonReentrant icoActive whenNotPaused payable {
uint256 ftmPurchaseInWei = msg.value;
uint256 tokensPurchase = getTokenAmount(ftmPurchaseInWei);
// _validatePurchase(signature, ftmPurchaseInWei, tokensPurchase, _msgSender());
// // Amount of FTM that has been raised
// ftmRaised = ftmRaised + ftmPurchaseInWei;
// // Add person to distrubuted map and tokens bought
// whitelist[_msgSender()].wallet = _msgSender();
// whitelist[_msgSender()].amountToReceive += tokensPurchase;
// whitelist[_msgSender()].ftmSpend += ftmPurchaseInWei;
// availableTokensICO = availableTokensICO - tokensPurchase;
// boughtTokensICO += tokensPurchase;
// Send the funds to the daoAddress
daoAddress.transfer(ftmPurchaseInWei);
emit TokensPurchased(_msgSender(), daoAddress, tokensPurchase);
}
function setToken(IERC20 _token) external onlyOwner {
require(address(token) != address(0), "Pre-Sale: Token is the zero address");
token = _token;
emit TokenAddress(address(token));
}
function setDistributedAmount(address _wallet, uint256 _amountInGwei) external onlyOwner {
whitelist[_wallet].amountToReceive = _amountInGwei;
emit DistrubutedAmount(_wallet, _amountInGwei);
}
function setRate(uint256 _rate) external onlyOwner {
rate = _rate;
emit Rate(rate);
}
function setPaused(bool _paused) external onlyOwner {
if (_paused) _pause();
else _unpause();
}
function setAvailableTokensICO(uint256 _availableTokensICO) public onlyOwner {
availableTokensICO = _availableTokensICO;
emit AvailableTokensICO(_availableTokensICO);
}
function setWhitelistSigner(address _whitelistSigner) public onlyOwner {
require(_whitelistSigner != address(0), "Pre-Sale: Invalid address");
whitelistSigner = _whitelistSigner;
emit WhitelistSigner(_whitelistSigner);
}
function setDaoAddress(address payable _daoAddress) external onlyOwner {
require(_daoAddress != address(0), "Pre-Sale: Invalid address");
daoAddress = _daoAddress;
emit DaoAddress(daoAddress);
}
function setMinPurchase(uint256 _minPurchase) external onlyOwner {
minPurchase = _minPurchase;
emit MinPurchase(_minPurchase);
}
function setMaxPurchase(uint256 _maxPurchase) external onlyOwner {
maxPurchase = _maxPurchase;
emit MaxPurchase(_maxPurchase);
}
function setRewardTokenCount(uint256 _rewardTokenCount) external onlyOwner {
rewardTokenCount = _rewardTokenCount;
emit RewardTokenCount(rewardTokenCount);
}
function getTokenAmount(uint256 _weiAmount) public view returns (uint256) {
return (_weiAmount * rewardTokenCount) / rate;
}
function getTokensInContract() public view returns (uint256) {
return token.balanceOf(address(this));
}
function withdrawalAmount(address _beneficiary) public view returns(uint256 amount) {
return whitelist[_beneficiary].amountToReceive;
}
function isWhitelisted(address _beneficiary, bytes memory signature) public view returns(bool) {
// Verify EIP-712 signature
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, keccak256(abi.encode(PRESALE_TYPEHASH, _beneficiary))));
address recoveredAddress = digest.recover(signature);
if(recoveredAddress != address(0) && recoveredAddress == address(whitelistSigner)) {
return true;
} else {
return false;
}
}
function withdrawLeftoversToken() external icoNotActive onlyOwner {
require(token.balanceOf(address(this)) > 0, 'Pre-Sale: Their is no tokens to withdraw');
token.approve(address(this), token.balanceOf(address(this)));
token.transfer(_msgSender(), token.balanceOf(address(this)));
emit WithdrawLeftovers(_msgSender(), token.balanceOf(address(this)));
}
function withdrawTokens() external nonReentrant whenNotPaused icoNotActive() {
require(address(token) != address(0), "Pre-Sale: Token is the zero address");
require(withdrawalAmount(_msgSender()) != 0, "Pre-Sale: Haven't bought any tokens");
require(withdrawalAmount(_msgSender()) <= getTokensInContract(), "Pre-Sale: Not enough tokens in contract to withdraw from");
token.transfer(_msgSender(), withdrawalAmount(_msgSender()));
whitelist[_msgSender()].amountToReceive = 0;
emit WithdrawRewards(_msgSender(), withdrawalAmount(_msgSender()));
}
function _validatePurchase(bytes memory _signature, uint256 _ftmPurchaseInWei, uint256 _tokensPurchase, address _beneficiary) internal {
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, keccak256(abi.encode(PRESALE_TYPEHASH, _beneficiary))));
address recoveredAddress = digest.recover(_signature);
require(recoveredAddress != address(0) && recoveredAddress == address(whitelistSigner), "Invalid signature");
require(_ftmPurchaseInWei >= minPurchase, 'Pre-Sale: Have to send at least: minPurchase');
require(_ftmPurchaseInWei <= maxPurchase, 'Pre-Sale: Have to send less than: maxPurchase');
require(availableTokensICO != 0, "Pre-Sale: No available tokens left");
require(_tokensPurchase != 0, "Pre-Sale: Value is 0");
require(_tokensPurchase <= availableTokensICO, "Pre-Sale: No tokens left to buy");
require(availableTokensICO - _tokensPurchase != 0, "Pre-Sale: Purchase amount is to high");
require((whitelist[_beneficiary].amountToReceive + _tokensPurchase) <= maxPurchase, 'Pre-Sale: Max purchase has been reached');
}
}
| 325,712 | 10,727 |
eb8205418993b87dd90d7a22cab265c265c6e6cd466728a087ad810d411dc58a
| 15,263 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TR/TREXLkqAFR2C2dA5oLD4R2M8GZpmiYATrh_TropixPool.sol
| 2,686 | 9,746 |
//SourceUnit: tronconomy.sol
pragma solidity ^0.5.17;
pragma experimental ABIEncoderV2;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor (address initialOwner) internal {
_owner = initialOwner;
emit OwnershipTransferred(address(0), initialOwner);
}
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;
}
}
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 MerkleProof {
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
bytes32 proofElement = proof[i];
if (computedHash <= proofElement) {
// Hash(current computed hash + current element of the proof)
computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
} else {
// Hash(current element of the proof + current computed hash)
computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
}
}
// Check if the computed hash (root) is equal to the provided root
return computedHash == root;
}
}
contract TropixPool is Ownable {
using SafeMath for uint256;
using MerkleProof for bytes32[];
uint8 private _fee = 10;
address private _feeWallet = 0xa9D45c637F527d8184Dfd3aE3270c661E7bFFF3A;
uint256 public minDepositAmount = 1;
uint256 public numPaymentCycles = 1;
mapping(address => uint256) public withdrawals;
mapping(address => uint256) public deposits;
// make nonpublic
mapping(uint256 => bytes32) public payeeRoots;
uint256 currentPaymentCycleStartBlock;
event PaymentCycleEnded(uint256 paymentCycle, uint256 startBlock, uint256 endBlock);
event PayeeWithdraw(address indexed payee, uint256 amount);
event Deposit(address indexed payer, uint256 amount);
constructor (address cOwner) public Ownable (cOwner){
currentPaymentCycleStartBlock = block.number;
}
function startNewPaymentCycle() internal onlyOwner returns(bool) {
require(block.number > currentPaymentCycleStartBlock);
emit PaymentCycleEnded(numPaymentCycles, currentPaymentCycleStartBlock, block.number);
numPaymentCycles = numPaymentCycles.add(1);
currentPaymentCycleStartBlock = block.number.add(1);
return true;
}
function submitPayeeMerkleRoot(bytes32 payeeRoot) public onlyOwner returns(bool) {
payeeRoots[numPaymentCycles] = payeeRoot;
startNewPaymentCycle();
return true;
}
function resetPaymentCycle() public onlyOwner returns(bool) {
emit PaymentCycleEnded(numPaymentCycles, currentPaymentCycleStartBlock, block.number);
numPaymentCycles = 0;
currentPaymentCycleStartBlock = block.number.add(1);
}
function setMinimumDepositAmount(uint256 minAmount) public onlyOwner returns(bool) {
minDepositAmount = minAmount;
return true;
}
function balanceForProofWithAddress(address _address, bytes memory proof) public view returns(uint256) {
bytes32[] memory meta;
bytes32[] memory _proof;
(meta, _proof) = splitIntoBytes32(proof, 2);
if (meta.length != 2) { return 0; }
uint256 paymentCycleNumber = uint256(meta[0]);
uint256 cumulativeAmount = uint256(meta[1]);
if (payeeRoots[paymentCycleNumber] == 0x0) { return 0; }
bytes32 leaf = keccak256(abi.encodePacked(_address,
cumulativeAmount));
if (withdrawals[_address] < cumulativeAmount &&
_proof.verify(payeeRoots[paymentCycleNumber], leaf)) {
return cumulativeAmount.sub(withdrawals[_address]);
} else {
return 0;
}
}
function balanceForProof(bytes memory proof) public view returns(uint256) {
return balanceForProofWithAddress(msg.sender, proof);
}
function totalBalance() public view returns(uint256) {
return address(this).balance;
}
function getPercent(uint part, uint whole) public pure returns(uint percent) {
uint numerator = part * 1000;
require(numerator > part);
uint temp = numerator / whole + 5; // proper rounding up
return temp / 10;
}
function withdraw(uint256 amount, bytes memory proof) public returns(bool) {
require(amount > 0);
require(!isContract(msg.sender) && msg.sender == tx.origin);
// check balance
require(address(this).balance >= amount);
uint256 balance = balanceForProof(proof);
require(balance >= amount);
withdrawals[msg.sender] = withdrawals[msg.sender].add(amount);
// check transfer
msg.sender.transfer(amount);
emit PayeeWithdraw(msg.sender, amount);
return true;
}
function adminDeposit() public payable returns(bool) {
return true;
}
function setAdminFee(uint8 _newfee) public onlyOwner {
require(_newfee <= 100);
_fee = _newfee;
}
function getAdminFee() public view returns (uint8) {
return _fee;
}
function setFeeWallet(address _account) public onlyOwner {
require(_account != address(0));
_feeWallet = _account;
}
function getFeeWallet() public view returns (address) {
return _feeWallet;
}
function deposit() public payable returns(bool) {
require(msg.value > 0);
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= minDepositAmount, "must meet minimum deposit amount");
deposits[msg.sender] = deposits[msg.sender].add(msg.value);
uint adminFee = msg.value.mul(_fee).div(100);
address payable wallet = address(uint160(_feeWallet));
wallet.transfer(adminFee);
emit Deposit(msg.sender, msg.value);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function splitIntoBytes32(bytes memory byteArray, uint256 numBytes32) internal pure returns (bytes32[] memory bytes32Array,
bytes32[] memory remainder) {
if (byteArray.length % 32 != 0 ||
byteArray.length < numBytes32.mul(32) ||
byteArray.length.div(32) > 50) { // Arbitrarily limiting this function to an array of 50 bytes32's to conserve gas
bytes32Array = new bytes32[](0);
remainder = new bytes32[](0);
return (bytes32Array, remainder);
}
bytes32Array = new bytes32[](numBytes32);
remainder = new bytes32[](byteArray.length.sub(64).div(32));
bytes32 _bytes32;
for (uint256 k = 32; k <= byteArray.length; k = k.add(32)) {
assembly {
_bytes32 := mload(add(byteArray, k))
}
if(k <= numBytes32*32){
bytes32Array[k.sub(32).div(32)] = _bytes32;
} else {
remainder[k.sub(96).div(32)] = _bytes32;
}
}
}
}
| 288,684 | 10,728 |
9bd20e71481fd9642a0b9a2bb4809acdfbf713845761d4585078e222695a70d2
| 12,949 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe1095934cae87c98494dbd5e23365107ecff9e2f.sol
| 3,380 | 12,198 |
pragma solidity ^0.4.25;
contract CryptoMinerClassic {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Crypto Miner Classic";
string public symbol = "CMC";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 15;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 5;
uint8 constant internal refferalFee_ = 35;
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 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;
}
function transferCheck() 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);
}
}
| 196,961 | 10,729 |
62a70fda97abc96e131e7d8bc630fcb3a1292c5f5ca0b7ebc4688c1ebe6e75f4
| 14,965 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x24021d38db53a938446ecb0a31b1267764d9d63d.sol
| 3,803 | 12,026 |
pragma solidity ^0.4.19;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract 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;
}
}
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 HODLIT is StandardToken, Ownable {
using SafeMath for uint256;
string public name = "HODL INCENTIVE TOKEN";
string public symbol = "HIT";
uint256 public decimals = 18;
uint256 public multiplicator = 10 ** decimals;
uint256 public totalSupply;
uint256 public ICDSupply;
uint256 public registeredUsers;
uint256 public claimedUsers;
uint256 public maxReferrals = 20;
uint256 public hardCap = SafeMath.mul(100000000, multiplicator);
uint256 public ICDCap = SafeMath.mul(20000000, multiplicator);
mapping (address => uint256) public etherBalances;
mapping (address => bool) public ICDClaims;
mapping (address => uint256) public referrals;
mapping (address => bool) public bonusReceived;
uint256 public regStartTime = 1519848000; // 28 feb 2018 20:00 GMT
uint256 public regStopTime = regStartTime + 7 days;
uint256 public POHStartTime = regStopTime;
uint256 public POHStopTime = POHStartTime + 7 days;
uint256 public ICDStartTime = POHStopTime;
uint256 public ICDStopTime = ICDStartTime + 7 days;
uint256 public PCDStartTime = ICDStopTime + 14 days;
address public ERC721Address;
modifier forRegistration {
require(block.timestamp >= regStartTime && block.timestamp < regStopTime);
_;
}
modifier forICD {
require(block.timestamp >= ICDStartTime && block.timestamp < ICDStopTime);
_;
}
modifier forERC721 {
require(msg.sender == ERC721Address && block.timestamp >= PCDStartTime);
_;
}
function HODLIT() public {
uint256 reserve = SafeMath.mul(30000000, multiplicator);
owner = msg.sender;
totalSupply = totalSupply.add(reserve);
balances[owner] = balances[owner].add(reserve);
Transfer(address(0), owner, reserve);
}
function() external payable {
revert();
}
function setERC721Address(address _ERC721Address) external onlyOwner {
ERC721Address = _ERC721Address;
}
function setMaxReferrals(uint256 _maxReferrals) external onlyOwner {
maxReferrals = _maxReferrals;
}
function registerEtherBalance(address _referral) external forRegistration {
require(msg.sender.balance > 0.2 ether &&
etherBalances[msg.sender] == 0 &&
_referral != msg.sender);
if (_referral != address(0) && referrals[_referral] < maxReferrals) {
referrals[_referral]++;
}
registeredUsers++;
etherBalances[msg.sender] = msg.sender.balance;
}
function claimTokens() external forICD {
require(ICDClaims[msg.sender] == false);
require(etherBalances[msg.sender] > 0);
require(etherBalances[msg.sender] <= msg.sender.balance + 50 finney);
ICDClaims[msg.sender] = true;
claimedUsers++;
require(mintICD(msg.sender, computeReward(etherBalances[msg.sender])));
}
function declareCheater(address _cheater) external onlyOwner {
require(_cheater != address(0));
ICDClaims[_cheater] = false;
etherBalances[_cheater] = 0;
}
function declareCheaters(address[] _cheaters) external onlyOwner {
for (uint256 i = 0; i < _cheaters.length; i++) {
require(_cheaters[i] != address(0));
ICDClaims[_cheaters[i]] = false;
etherBalances[_cheaters[i]] = 0;
}
}
function mintPCD(address _to, uint256 _amount) external forERC721 returns(bool) {
require(_to != address(0));
require(_amount + totalSupply <= hardCap);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
etherBalances[_to] = _to.balance;
Transfer(address(0), _to, _amount);
return true;
}
function claimTwitterBonus() external forICD {
require(balances[msg.sender] > 0 && !bonusReceived[msg.sender]);
bonusReceived[msg.sender] = true;
mintICD(msg.sender, multiplicator.mul(20));
}
function claimReferralBonus() external forICD {
require(referrals[msg.sender] > 0 && balances[msg.sender] > 0);
uint256 cache = referrals[msg.sender];
referrals[msg.sender] = 0;
mintICD(msg.sender, SafeMath.mul(cache * 20, multiplicator));
}
function computeReward(uint256 _amount) internal view returns(uint256) {
if (_amount < 1 ether) return SafeMath.mul(20, multiplicator);
if (_amount < 2 ether) return SafeMath.mul(100, multiplicator);
if (_amount < 3 ether) return SafeMath.mul(240, multiplicator);
if (_amount < 4 ether) return SafeMath.mul(430, multiplicator);
if (_amount < 5 ether) return SafeMath.mul(680, multiplicator);
if (_amount < 6 ether) return SafeMath.mul(950, multiplicator);
if (_amount < 7 ether) return SafeMath.mul(1260, multiplicator);
if (_amount < 8 ether) return SafeMath.mul(1580, multiplicator);
if (_amount < 9 ether) return SafeMath.mul(1900, multiplicator);
if (_amount < 10 ether) return SafeMath.mul(2240, multiplicator);
if (_amount < 11 ether) return SafeMath.mul(2560, multiplicator);
if (_amount < 12 ether) return SafeMath.mul(2890, multiplicator);
if (_amount < 13 ether) return SafeMath.mul(3210, multiplicator);
if (_amount < 14 ether) return SafeMath.mul(3520, multiplicator);
if (_amount < 15 ether) return SafeMath.mul(3830, multiplicator);
if (_amount < 16 ether) return SafeMath.mul(4120, multiplicator);
if (_amount < 17 ether) return SafeMath.mul(4410, multiplicator);
if (_amount < 18 ether) return SafeMath.mul(4680, multiplicator);
if (_amount < 19 ether) return SafeMath.mul(4950, multiplicator);
if (_amount < 20 ether) return SafeMath.mul(5210, multiplicator);
if (_amount < 21 ether) return SafeMath.mul(5460, multiplicator);
if (_amount < 22 ether) return SafeMath.mul(5700, multiplicator);
if (_amount < 23 ether) return SafeMath.mul(5930, multiplicator);
if (_amount < 24 ether) return SafeMath.mul(6150, multiplicator);
if (_amount < 25 ether) return SafeMath.mul(6360, multiplicator);
if (_amount < 26 ether) return SafeMath.mul(6570, multiplicator);
if (_amount < 27 ether) return SafeMath.mul(6770, multiplicator);
if (_amount < 28 ether) return SafeMath.mul(6960, multiplicator);
if (_amount < 29 ether) return SafeMath.mul(7140, multiplicator);
if (_amount < 30 ether) return SafeMath.mul(7320, multiplicator);
if (_amount < 31 ether) return SafeMath.mul(7500, multiplicator);
if (_amount < 32 ether) return SafeMath.mul(7660, multiplicator);
if (_amount < 33 ether) return SafeMath.mul(7820, multiplicator);
if (_amount < 34 ether) return SafeMath.mul(7980, multiplicator);
if (_amount < 35 ether) return SafeMath.mul(8130, multiplicator);
if (_amount < 36 ether) return SafeMath.mul(8270, multiplicator);
if (_amount < 37 ether) return SafeMath.mul(8410, multiplicator);
if (_amount < 38 ether) return SafeMath.mul(8550, multiplicator);
if (_amount < 39 ether) return SafeMath.mul(8680, multiplicator);
if (_amount < 40 ether) return SafeMath.mul(8810, multiplicator);
if (_amount < 41 ether) return SafeMath.mul(8930, multiplicator);
if (_amount < 42 ether) return SafeMath.mul(9050, multiplicator);
if (_amount < 43 ether) return SafeMath.mul(9170, multiplicator);
if (_amount < 44 ether) return SafeMath.mul(9280, multiplicator);
if (_amount < 45 ether) return SafeMath.mul(9390, multiplicator);
if (_amount < 46 ether) return SafeMath.mul(9500, multiplicator);
if (_amount < 47 ether) return SafeMath.mul(9600, multiplicator);
if (_amount < 48 ether) return SafeMath.mul(9700, multiplicator);
if (_amount < 49 ether) return SafeMath.mul(9800, multiplicator);
if (_amount < 50 ether) return SafeMath.mul(9890, multiplicator);
return SafeMath.mul(10000, multiplicator);
}
function mintICD(address _to, uint256 _amount) internal returns(bool) {
require(_to != address(0));
require(_amount + ICDSupply <= ICDCap);
totalSupply = totalSupply.add(_amount);
ICDSupply = ICDSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
etherBalances[_to] = _to.balance;
Transfer(address(0), _to, _amount);
return true;
}
}
| 201,618 | 10,730 |
c756ce50c7bd46f492524d5546f4735227140eda9ac6bd67f4c11162f4828bf3
| 33,862 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TC/TCwLncuwcdJLDTBcCA5XVEjuLVeEkuiXfq_TRONtopia_Dividend_Pool.sol
| 5,508 | 21,523 |
//SourceUnit: topiaDividend.sol
pragma solidity 0.4.25;
//
//------------------------ SafeMath Library -------------------------//
//
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
//
//------------------ Contract to Manage Ownership -------------------//
//
contract owned {
address internal owner;
address internal newOwner;
address internal signer;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
signer = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlySigner {
require(msg.sender == signer);
_;
}
function changeSigner(address _signer) public onlyOwner {
signer = _signer;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
//this flow is to prevent transferring ownership to wrong wallet by mistake
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
//
//--------------------- GAMES CONTRACT INTERFACE ---------------------//
//
interface InterfaceGAMES {
function displayAvailableDividend() external returns (bool, uint256);
function requestDividendPayment(uint256 amount) external returns(bool);
function getAvailableDivRake() external returns (uint256);
function requestDivRakePayment(uint256 amount) external returns(bool);
}
//
//--------------------- TOPIA TOKEN CONTRACT INTERFACE -------------------//
//
interface TRONtopiaInterface
{
function transfer(address recipient, uint amount) external returns(bool);
function mintToken(address _user, uint256 _tronAmount) external returns(bool);
function referrers(address user) external returns(address);
function updateReferrer(address _user, address _referrer) external returns(bool);
function payReferrerBonusOnly(address _user, uint256 _refBonus, uint256 _trxAmount) external returns(bool);
function payReferrerBonusAndAddReferrer(address _user, address _referrer, uint256 _trxAmount, uint256 _refBonus) external returns(bool);
}
//
//------------------ TOPIA FREEZING CONTRACT INTERFACE -------------------//
//
interface topiaFreezingInterface
{
function remainingTimeOfMyFreeze(address _user) external returns(uint256,uint256,uint256);
function totalFrozenTopiaIndividual(uint256 freezeTier) external returns(uint256);
}
//
//--------------------- VOUCHERS CONTRACT INTERFACE ---------------------//
//
interface InterfaceVOUCHERS
{
function mintVouchers(address _user, uint256 _mainBetSUN, uint256 _siteBetSUN) external returns(bool);
function mintingBasePrice(address gameAddress) external view returns(uint256);
}
//
//--------------------- DIV POOL MAIN CODE STARTS HERE --------------------//
//
contract TRONtopia_Dividend_Pool is owned{
using SafeMath for uint256;
address public topiaTokenContractAddress;
address public topiaFreezingContractAddress;
//address public voucherContractAddress;
address public refPoolContractAddress;
address public leaderBoardContractAddress;
uint256 public refPoolPercentSUN = 1000000; //this is in tron decimal / SUN - default 1%
uint256 public leaderboardsPercentSUN = 1000000; //this is in tron decimal / SUN - default 1%
uint256 public sharesPoolPercentSUN = 1000000; //this is in tron decimal / SUN - default 1%
address public sharesPoolAddress;
address[] public whitelistCallerArray;
bool public globalHalt; //when this variabe will be true, it will stop main functionality!
uint256 private constant tronDecimals = 1e6;
uint64 public availableNoOfDistroTier0 = 7;
uint64 public availableNoOfDistroTier1 = 30;
uint64 public availableNoOfDistroTier2 = 60;
uint256 private confirmedDividendForFreeze;
mapping (address => bool) public whitelistCaller;
mapping (address => uint256) internal whitelistCallerArrayIndex;
mapping(address => uint256) public mainDividendPaid;
//public variables DIV RAKE
uint256 public dividendPaidLastTimeDivRake = now;
uint256 public dividendAccumulatedDivRake;
uint256 public dividendRemainderDivRake;
uint256 public divPaidAllTimeDivRake;
uint256 public topiaFrozenAtDistributionDivRake;
uint64 public totalDividendsPaidNumberDivRake;
mapping(address => uint64) public noOfDivPaidAfterFreezeDivRake; //tracks number of dividend distribution attempted after user froze
mapping(uint64 => uint256) public divPaidIndividual;
mapping(uint64 => uint256) public topiaFrozenIndividual;
//events
event DividendPaidDivRake(uint256 indexed totalDividend, uint256 indexed payableAmount);
event UserWithdrawDividend(address indexed user, uint256 availableMainDividend);
function () payable external {}
constructor() public { }
function requestDividendPayment(uint256 dividendAmount) public returns(bool) {
require(msg.sender == topiaTokenContractAddress, 'Unauthorised caller');
msg.sender.transfer(dividendAmount);
return true;
}
function updateContractAddresses(address _topiaTokenContractAddress, address _refPoolContractAddress, address _leaderBoardContractAddress, address _topiaFreezingContractAddress) public onlyOwner returns(string){
topiaTokenContractAddress = _topiaTokenContractAddress;
//voucherContractAddress = _voucherContractAddress;
refPoolContractAddress = _refPoolContractAddress;
leaderBoardContractAddress = _leaderBoardContractAddress;
topiaFreezingContractAddress = _topiaFreezingContractAddress;
return "Topia Token, refPool and leaderBoardPool Contract Addresses Updated";
}
function requestFundFromGameContracts() public onlySigner returns(bool){
//first finding excesive fund from ALL game contracts
uint256 totalGameContracts = whitelistCallerArray.length;
for(uint i=0; i < totalGameContracts; i++){
uint256 amount = InterfaceGAMES(whitelistCallerArray[i]).getAvailableDivRake();
if(amount > 0){
//if status is true, which means particular game has positive dividend available
//we will request that dividend TRX from game contract to this dividend contract
InterfaceGAMES(whitelistCallerArray[i]).requestDivRakePayment(amount);
dividendAccumulatedDivRake += amount;
}
//else nothing will happen
}
}
function addWhitelistAddress(address _newAddress) public onlyOwner returns(string){
require(!whitelistCaller[_newAddress], 'No same Address again');
whitelistCaller[_newAddress] = true;
whitelistCallerArray.push(_newAddress);
whitelistCallerArrayIndex[_newAddress] = whitelistCallerArray.length - 1;
return "Whitelisting Address added";
}
function removeWhitelistAddress(address _address) public onlyOwner returns(string){
require(_address != address(0), 'Invalid Address');
require(whitelistCaller[_address], 'This Address does not exist');
whitelistCaller[_address] = false;
uint256 arrayIndex = whitelistCallerArrayIndex[_address];
address lastElement = whitelistCallerArray[whitelistCallerArray.length - 1];
whitelistCallerArray[arrayIndex] = lastElement;
whitelistCallerArrayIndex[lastElement] = arrayIndex;
whitelistCallerArray.length--;
return "Whitelisting Address removed";
}
function updateRefPoolPercent(uint256 _refPoolPercentSUN) public onlyOwner returns(string){
require(_refPoolPercentSUN < 100000000, 'amount can not be more than 100000000');
refPoolPercentSUN = _refPoolPercentSUN;
return ("refPoolPercent updated successfully");
}
function updateLeaderboardPercent(uint256 _leaderBoardPercentSUN) public onlyOwner returns(string){
require(_leaderBoardPercentSUN < 100000000, 'amount can not be more than 100000000');
leaderboardsPercentSUN = _leaderBoardPercentSUN;
return ("leaderboardsPercentSUN updated successfully");
}
function updateSharesPoolDetail(uint256 _newPercentSUN, address _newAddress) public onlyOwner returns(string){
require(_newPercentSUN < 100000000, 'amount can not be more than 100000000');
sharesPoolPercentSUN = _newPercentSUN;
sharesPoolAddress = _newAddress;
return ("leaderboardsPercentSUN updated successfully");
}
function displayAvailableDividendALL() public view returns(bool, uint256){
//we will check dividends of all the game contract individually
uint256 totalGameContracts = whitelistCallerArray.length;
uint256 totalDividend;
for(uint i=0; i < totalGameContracts; i++){
uint256 amount = InterfaceGAMES(whitelistCallerArray[i]).getAvailableDivRake();
if(amount > 0){
totalDividend += amount;
}
}
if(totalDividend > 0 || dividendAccumulatedDivRake > 0){
//we deduct 1% of finalAmount from itself for Leaderboard distribution
uint256 leaderBoardShare = totalDividend * leaderboardsPercentSUN / 100000000;
//we deduct RefPool share as well
uint256 refPoolShare = totalDividend * refPoolPercentSUN / 100000000; //refPoolPercentSUN is in SUN
// we deduct shares pool %
uint256 sharesPoolShare = totalDividend * sharesPoolPercentSUN / 100000000;
return (true, (totalDividend + dividendAccumulatedDivRake - (leaderBoardShare + refPoolShare + sharesPoolShare)));
}
}
function distributeMainDividend() public returns(uint256){
//signer can call this function anytime
//but if he does not call it after 7 days, then anyone can call this and distribute the dividend.
//this is to increase trust in player community.
if(msg.sender != signer){
require(dividendPaidLastTimeDivRake + 604800 < now, 'You need to wait 7 days to Do This');
}
uint256 bronzeTopiaAllUsers = topiaFreezingInterface(topiaFreezingContractAddress).totalFrozenTopiaIndividual(0);
uint256 silverTopiaAllUsers = topiaFreezingInterface(topiaFreezingContractAddress).totalFrozenTopiaIndividual(1);
uint256 goldTopiaAllUsers = topiaFreezingInterface(topiaFreezingContractAddress).totalFrozenTopiaIndividual(2);
uint256 totalTopiaFrozen = bronzeTopiaAllUsers + silverTopiaAllUsers + goldTopiaAllUsers;
require(totalTopiaFrozen > 0, 'No one has frozen anything');
//we will check dividends of all the game contract individually
uint256 totalGameContracts = whitelistCallerArray.length;
uint256 totalDividend;
for(uint i=0; i < totalGameContracts; i++){
uint256 amount = InterfaceGAMES(whitelistCallerArray[i]).getAvailableDivRake();
if(amount > 0){
//if status is true, which means particular game has positive dividend available
totalDividend += amount;
//we will request that dividend TRX from game contract to this token contract
require(InterfaceGAMES(whitelistCallerArray[i]).requestDivRakePayment(amount), 'could not transfer trx');
}
}
dividendPaidLastTimeDivRake = now;
if(totalDividend > 0 || dividendAccumulatedDivRake > 0){
//transfer the referral and leaderboard pool amount to their contracts.
require(refPoolContractAddress.call.value(totalDividend * refPoolPercentSUN / 100000000).gas(70000)(), 'refPool transfer failed');
require(leaderBoardContractAddress.call.value(totalDividend * leaderboardsPercentSUN / 100000000).gas(70000)(), 'leaderBoardPool transfer failed');
sharesPoolAddress.transfer(totalDividend * sharesPoolPercentSUN / 100000000);
uint256 finalDividendAmount = dividendAccumulatedDivRake + (totalDividend * (100000000 - leaderboardsPercentSUN - refPoolPercentSUN - sharesPoolPercentSUN) / 100000000);
//now deducting bronze freeze tier difference.
uint256 bronzrTierAmount = (finalDividendAmount * (100 * bronzeTopiaAllUsers /totalTopiaFrozen) / 100) * 50 / 100; //50% of it goes into distribution
//silver tier
uint256 silverTierAmount = (finalDividendAmount * (100 * silverTopiaAllUsers /totalTopiaFrozen) / 100) * 75 / 100; //75%
//gold tier
uint256 goldTierAmount = finalDividendAmount * (100 * goldTopiaAllUsers / totalTopiaFrozen) / 100; //100%
dividendAccumulatedDivRake = finalDividendAmount - (bronzrTierAmount + silverTierAmount + goldTierAmount);
confirmedDividendForFreeze = confirmedDividendForFreeze.add(bronzrTierAmount + silverTierAmount + goldTierAmount); //98% to dividend pool
divPaidAllTimeDivRake += bronzrTierAmount + silverTierAmount + goldTierAmount;
divPaidIndividual[totalDividendsPaidNumberDivRake] = bronzrTierAmount + silverTierAmount + goldTierAmount;
topiaFrozenAtDistributionDivRake += totalTopiaFrozen;
topiaFrozenIndividual[totalDividendsPaidNumberDivRake] = totalTopiaFrozen;
totalDividendsPaidNumberDivRake++;
emit DividendPaidDivRake(totalDividend, finalDividendAmount);
return finalDividendAmount;
}
//default return zero
}
function outstandingDivWithdrawFreeze(address user) public returns(bool){
require(msg.sender == topiaTokenContractAddress || msg.sender == topiaFreezingContractAddress, 'Unauthorised caller');
//processing divRake outstanding withdraws
uint256 availableMainDividendDivRake = userConfirmedDividendDivRake(user);
//update divRake div trackers, regardless user has outstanding div or not
updateDivTrackersDivRake(user);
if(availableMainDividendDivRake > 0){
//if user have any outstanding divs, then it will be withdrawn.
//so after this freeze, user only can withdraw divs from next subsequent div distributions!
user.transfer(availableMainDividendDivRake);
emit UserWithdrawDividend(user, availableMainDividendDivRake);
}
return true;
}
function outstandingDivWithdrawUnfreeze(address user) public returns(bool){
require(msg.sender == topiaTokenContractAddress || msg.sender == topiaFreezingContractAddress, 'Unauthorised caller');
//processing divRake outstanding withdraws
uint256 availableMainDividendDivRake = userConfirmedDividendDivRake(user);
if(availableMainDividendDivRake > 0){
//if user have any outstanding divs, then it will be withdrawn.
//so after this freeze, user only can withdraw divs from next subsequent div distributions!
user.transfer(availableMainDividendDivRake);
emit UserWithdrawDividend(user, availableMainDividendDivRake);
}
return true;
}
function outstandingDivWithdrawUpgrade(address user) public returns(bool){
require(msg.sender == topiaTokenContractAddress, 'Unauthorised caller');
//processing divRake outstanding withdraws
uint256 availableMainDividendDivRake = userConfirmedDividendDivRake(user);
if(availableMainDividendDivRake > 0){
//update div rake tracker
updateDivTrackersDivRake(user);
//if user have any outstanding divs, then it will be withdrawn.
//so after this freeze, user only can withdraw divs from next subsequent div distributions!
user.transfer(availableMainDividendDivRake);
emit UserWithdrawDividend(user, availableMainDividendDivRake);
}
return true;
}
function changeGlobalHalt() onlySigner public returns(string) {
if (globalHalt == false){
globalHalt = true;
}
else{
globalHalt = false;
}
return "globalHalt status changed";
}
function reInvestDividendRemainderDivRake() public onlyOwner returns(string){
require(dividendRemainderDivRake > 0, 'Invalid amount');
require(!globalHalt, 'Global Halt is on');
dividendAccumulatedDivRake += dividendRemainderDivRake ;
dividendRemainderDivRake=0;
return "dividendRemainder is sent to div pool";
}
function userConfirmedDividendDivRake(address user) public view returns(uint256){
//if there are more dividend distribution after user has frozen token
(, uint256 freezeAmount, uint256 userSlab) = topiaFreezingInterface(topiaFreezingContractAddress).remainingTimeOfMyFreeze(user);
uint256 totalDividendsPaidNumberLocal = totalDividendsPaidNumberDivRake;
uint64 noOfDivPaidAfterFreezeLocal = noOfDivPaidAfterFreezeDivRake[user];
if(totalDividendsPaidNumberLocal >noOfDivPaidAfterFreezeLocal && freezeAmount > 0){
uint256 noOfDistro;
if(userSlab == 0){ //for bronze
if((totalDividendsPaidNumberLocal - noOfDivPaidAfterFreezeLocal) > availableNoOfDistroTier0){
noOfDistro = availableNoOfDistroTier0;
}
else{
noOfDistro = totalDividendsPaidNumberLocal - noOfDivPaidAfterFreezeLocal;
}
}
else if(userSlab == 1){ //for silver
if((totalDividendsPaidNumberLocal - noOfDivPaidAfterFreezeLocal) > availableNoOfDistroTier1){
noOfDistro = availableNoOfDistroTier1;
}
else{
noOfDistro = totalDividendsPaidNumberLocal - noOfDivPaidAfterFreezeLocal;
}
}
else{ //for gold
if((totalDividendsPaidNumberLocal - noOfDivPaidAfterFreezeLocal) > availableNoOfDistroTier2){
noOfDistro = availableNoOfDistroTier2;
}
else{
noOfDistro = totalDividendsPaidNumberLocal - noOfDivPaidAfterFreezeLocal;
}
}
uint256 newDividendPoolAmount;
uint256 totalFrozenTopia;
for(uint64 i=noOfDivPaidAfterFreezeLocal; i < noOfDistro+noOfDivPaidAfterFreezeLocal; i++){
newDividendPoolAmount += divPaidIndividual[i];
totalFrozenTopia += topiaFrozenIndividual[i];
}
//first calculating user share percentage = user freeze tokens * 100 / total frozen tokens
//the reason for the number 1000000, is to have sharePercentage variable have more decimals.
uint256 sharePercentage = freezeAmount * 100 * 1000000 / (totalFrozenTopia / noOfDistro) ;
if (userSlab == 0) //Bronze
{
sharePercentage -= sharePercentage / 2 ; // 50% reduced
}
else if (userSlab == 1) //Silver
{
sharePercentage -= sharePercentage * 25 / 100 ; // 25% reduced
}
// for (gold = 2) 100% means 0% reduced
//now calculating final trx amount from (available dividend pool * share percentage / 100)
if(newDividendPoolAmount * sharePercentage > 0){
return newDividendPoolAmount * sharePercentage / 100 / 1000000;
}
}
//by default it will return zero
}
function withdrawDividendDivRake() public returns(bool) {
//globalHalt will revert this function
require(!globalHalt, 'Global Halt is on');
address user = msg.sender;
//processing divRake dividend
uint256 availableMainDividend = userConfirmedDividendDivRake(user);
if(availableMainDividend > 0){
//update divRake div trackers
updateDivTrackersDivRake(user);
user.transfer(availableMainDividend);
emit UserWithdrawDividend(user, availableMainDividend);
return true;
}
// be default return false;
}
function updateDivTrackersDivRake(address user) internal{
noOfDivPaidAfterFreezeDivRake[user] = totalDividendsPaidNumberDivRake;
}
function changeNoOfDistroBasedOnTiers(uint64 availableNoOfDistroTier0_, uint64 availableNoOfDistroTier1_, uint64 availableNoOfDistroTier2_) public onlyOwner returns (string){
availableNoOfDistroTier0 = availableNoOfDistroTier0_;
availableNoOfDistroTier1 = availableNoOfDistroTier1_;
availableNoOfDistroTier2 = availableNoOfDistroTier2_;
return ("No Of Distro Based On Tiers updated successfully");
}
}
| 304,228 | 10,731 |
6edd04fb117e2f6059467452011bb5e8ec0be31b86ed4577a5eb498d1f6ce4a7
| 14,890 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x26135e15482b65845418e084f614bd340ddb3b8a.sol
| 4,069 | 14,552 |
pragma solidity ^0.4.25;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract LikeChainRelayLogicInterface {
function commitWithdrawHash(uint64 height, uint64 round, bytes _payload) public;
function updateValidator(address[] _newValidators, bytes _proof) public;
function withdraw(bytes _withdrawInfo, bytes _proof) public;
function upgradeLogicContract(address _newLogicContract, bytes _proof) public;
event Upgraded(uint256 _newLogicContractIndex, address _newLogicContract);
}
contract LikeChainRelayState {
uint256 public logicContractIndex;
address public logicContract;
IERC20 public tokenContract;
address[] public validators;
struct ValidatorInfo {
uint8 index;
uint32 power;
}
mapping(address => ValidatorInfo) public validatorInfo;
uint256 public totalVotingPower;
uint public lastValidatorUpdateTime;
uint public latestBlockHeight;
bytes32 public latestWithdrawHash;
mapping(bytes32 => bool) public consumedIds;
mapping(bytes32 => bytes32) public reserved;
}
contract LikeChainRelayLogic is LikeChainRelayState, LikeChainRelayLogicInterface {
constructor(address[] _validators, uint32[] _votingPowers, address _tokenContract) public {
uint len = _validators.length;
require(len > 0);
require(len < 256);
require(_votingPowers.length == len);
for (uint8 i = 0; i < len; i += 1) {
address v = _validators[i];
require(validatorInfo[v].power == 0);
uint32 power = _votingPowers[i];
require(power > 0);
validators.push(v);
validatorInfo[v] = ValidatorInfo({
index: i,
power: power
});
totalVotingPower += power;
}
tokenContract = IERC20(_tokenContract);
}
function _proofRootHash(bytes32 _key, bytes32 _value, bytes _proof) internal view returns (bytes32 rootHash) {
assembly {
let start := mload(0x40)
let p := start
let curHashStart := add(start, 128)
let data := add(_proof, 33) // 32 byte length + 1 byte reserved
let len := and(mload(sub(data, 31)), 0xff) // version length
if gt(len, 9) { revert(0, 0) } // version is uint64, so the varint encoded should never longer than 9 bytes
data := add(data, 1)
mstore(p, hex"0002")
p := add(p, 2)
mstore(p, mload(data))
data := add(data, len)
p := add(p, len)
mstore8(p, 32) // amino length-prefixed encoding for []byte (length 32)
p := add(p, 1)
mstore(p, _key)
p := add(p, 32)
mstore8(p, 32) // amino length-prefixed encoding for []byte (length 32)
p := add(p, 1)
mstore(p, _value)
p := add(p, 32)
let _ := staticcall(gas, 2, start, sub(p, start), curHashStart, 32)
len := and(mload(sub(data, 31)), 0xff) // number of path nodes
data := add(data, 1)
for { let i := len } gt(i, 0) { i := sub(i, 1) } {
p := start
len := and(mload(sub(data, 31)), 0xff) // 1 bit left-right indicator, 7 bits length
let order := and(len, 0x80)
len := and(len, 0x7f)
if gt(len, 19) { revert(0, 0) } // 1-byte height (< 128) + 9-byte 64-bit varint-encoded numbers * 2
data := add(data, 1)
mstore(p, mload(data))
p := add(p, len)
data := add(data, len)
switch order
case 0 {
mstore8(p, 32) // amino length-prefixed encoding for []byte
p := add(p, 1)
mstore(p, mload(curHashStart))
p := add(p, 32)
mstore8(p, 32) // amino length-prefixed encoding for []byte
p := add(p, 1)
mstore(p, mload(data))
p := add(p, 32)
} default {
mstore8(p, 32) // amino length-prefixed encoding for []byte
p := add(p, 1)
mstore(p, mload(data))
p := add(p, 32)
mstore8(p, 32) // amino length-prefixed encoding for []byte
p := add(p, 1)
mstore(p, mload(curHashStart))
p := add(p, 32)
}
data := add(data, 32)
_ := staticcall(gas, 2, start, sub(p, start), curHashStart, 32)
}
len := mload(_proof)
if gt(sub(data, add(_proof, 32)), len) {
revert(0, 0)
}
rootHash := mload(curHashStart)
}
return rootHash;
}
function commitWithdrawHash(uint64 height, uint64 round, bytes _payload) public {
assembly {
function getNByte(p, n) -> bs {
if gt(n, 32) {
revert(0, 0)
}
let numberOfOnes := mul(n, 8)
let numberOfZeros := sub(256, numberOfOnes)
let mask := 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
mask := xor(mask, sub(exp(2, numberOfZeros), 1))
bs := and(mload(p), mask)
}
function getOneByte(p) -> b {
b := byte(0, mload(p))
}
function reconstructPrefix(p, height, round) -> next {
mstore8(p, 0x00) // place-holder for length prefix
p := add(p, 1)
mstore8(p, 0x08) // field number for `type`
p := add(p, 1)
mstore8(p, 0x02) // value for `precommit` type
p := add(p, 1)
if gt(height, 0) {
mstore8(p, 0x11) // field number for `height`
p := add(p, 1)
for { let i := 0 } lt(i, 8) { i := add(i, 1) } {
mstore8(p, mod(height, 0x100))
height := div(height, 0x100)
p := add(p, 1)
}
}
if gt(round, 0) {
mstore8(p, 0x19) // field number for `round`
p := add(p, 1)
for { let i := 0 } lt(i, 8) { i := add(i, 1) } {
mstore8(p, mod(round, 0x100))
height := div(round, 0x100)
p := add(p, 1)
}
}
next := p
}
function extractBlockHash(suffix) -> blockHash {
blockHash := mload(add(suffix, 4))
}
function memcpy(dst, src, len) {
let dstEnd := add(dst, len)
for { } lt(dst, dstEnd) { dst := add(dst, 32) src := add(src, 32) } {
mstore(dst, mload(src))
}
}
function reconstructSignBytes(p, timeStart, time, timeLen, suffixSrc, suffixLen) -> end {
let start := p
mstore(timeStart, time)
p := add(timeStart, timeLen)
memcpy(p, suffixSrc, suffixLen)
end := add(p, suffixLen)
let len := sub(end, add(start, 1))
mstore8(start, len)
}
function getVoter(p, timeStart, suffixSrc, suffixLen) -> voter, next {
let msgStart := mload(0x40)
let timeLen := getOneByte(p)
if gt(timeLen, 15) { revert(0, 0) }
p := add(p, 1)
let time := getNByte(p, timeLen)
p := add(p, timeLen)
let msgEnd := reconstructSignBytes(msgStart, timeStart, time, timeLen, suffixSrc, suffixLen)
let buf := add(msgStart, 128)
let _ := staticcall(gas, 2, msgStart, sub(msgEnd, msgStart), buf, 32) // SHA-256 hash, at buf[0:32]
mstore(add(buf, 32), getOneByte(p)) // v at buf[32:64]
p := add(p, 1)
mstore(add(buf, 64), mload(p)) // r at buf[64:96]
p := add(p, 32)
mstore(add(buf, 96), mload(p)) // s at buf[96:128]
p := add(p, 32)
let succ := staticcall(gas, 1, buf, 128, buf, 32)
if iszero(succ) {
revert(0, 0)
}
voter := mload(buf)
next := p
}
function getVoterInfo(addr) -> index, power {
let buf := add(mload(0x40), 128)
mstore(buf, addr)
mstore(add(buf, 32), validatorInfo_slot)
let slot := keccak256(buf, 64)
let votingInfo := sload(slot)
if eq(votingInfo, 0) {
revert(0, 0)
}
index := and(votingInfo, 0xFF)
power := and(div(votingInfo, 0x100), 0xFFFFFFFF)
}
function accumulateVoterPower(voter, votedSet, power) -> newVotedSet, newPower {
let voterIndex, voterPower := getVoterInfo(voter)
let mask := exp(2, voterIndex)
if iszero(eq(0, and(votedSet, mask))) {
revert(0, 0)
}
newVotedSet := or(votedSet, mask)
newPower := add(power, voterPower)
}
function checkVotes(p, height, round) -> blockHash, next {
let votedSet := 0
let voterPower := 0
let suffixLen := getOneByte(p)
if gt(suffixLen, 92) { revert(0, 0) }
p := add(p, 1)
let suffixSrc := p
p := add(p, suffixLen)
blockHash := extractBlockHash(suffixSrc)
let msgStart := mload(0x40)
let timeStart := reconstructPrefix(msgStart, height, round)
let votesCount := getOneByte(p)
p := add(p, 1)
for {} gt(votesCount, 0) { votesCount := sub(votesCount, 1) } {
let voter
voter, p := getVoter(p, timeStart, suffixSrc, suffixLen)
votedSet, voterPower := accumulateVoterPower(voter, votedSet, voterPower)
}
if iszero(gt(mul(voterPower, 3), mul(sload(totalVotingPower_slot), 2))) {
revert(0, 0)
}
next := p
}
function extractAndProofWithdrawHash(p, blockHash) -> withdrawHash {
let buf := mload(0x40)
let aminoEncodedAppHashLen := add(getOneByte(p), 1)
memcpy(buf, p, aminoEncodedAppHashLen)
withdrawHash := mload(add(p, 1))
p := add(p, aminoEncodedAppHashLen)
let left := add(buf, 1)
let right := add(buf, 34)
let _ := staticcall(gas, 2, buf, aminoEncodedAppHashLen, left, 32)
mstore8(sub(left, 1), 32)
mstore8(sub(right, 1), 32)
mstore(right, mload(p))
p := add(p, 32)
_ := staticcall(gas, 2, buf, 66, left, 32)
mstore(right, mload(p))
p := add(p, 32)
_ := staticcall(gas, 2, buf, 66, right, 32)
mstore(left, mload(p))
p := add(p, 32)
_ := staticcall(gas, 2, buf, 66, right, 32)
mstore(left, mload(p))
p := add(p, 32)
_ := staticcall(gas, 2, buf, 66, buf, 32)
if iszero(eq(blockHash, mload(buf))) {
revert(0, 0)
}
}
if iszero(gt(height, sload(latestBlockHeight_slot))) {
revert(0, 0)
}
let blockHash
let p := add(_payload, 32)
blockHash, p := checkVotes(p, height, round)
let withdrawHash := extractAndProofWithdrawHash(p, blockHash)
sstore(latestBlockHeight_slot, height)
sstore(latestWithdrawHash_slot, withdrawHash)
}
}
function _proofAndExtractWithdraw(bytes _withdrawInfo, bytes _proof) internal returns (address to, uint256 value, uint256 fee) {
bytes32 id = sha256(_withdrawInfo);
require(!consumedIds[id]);
consumedIds[id] = true;
bytes32 proofValueHash = hex"4bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a"; // sha256 of hex"01"
bytes32 rootHash = _proofRootHash(id, proofValueHash, _proof);
require(rootHash == latestWithdrawHash);
assembly {
to := mload(add(_withdrawInfo, 40))
value := mload(add(_withdrawInfo, 72))
fee := mload(add(_withdrawInfo, 104))
}
return (to, value, fee);
}
function withdraw(bytes _withdrawInfo, bytes _proof) public {
address to;
uint256 value;
uint256 fee;
(to, value, fee) = _proofAndExtractWithdraw(_withdrawInfo, _proof);
tokenContract.transfer(msg.sender, fee);
tokenContract.transfer(to, value);
}
function updateValidator(address[] _newValidators, bytes _proof) public {
}
function upgradeLogicContract(address _newLogicContract, bytes _proof) public {
logicContractIndex += 1;
bytes12 keyBeforeHash = bytes12(uint96(bytes12("exec")) | uint96(logicContractIndex));
bytes32 key = sha256(abi.encodePacked(keyBeforeHash));
bytes32 proofValueHash = sha256(abi.encodePacked(_newLogicContract));
bytes32 rootHash = _proofRootHash(key, proofValueHash, _proof);
require(rootHash == latestWithdrawHash);
logicContract = _newLogicContract;
emit Upgraded(logicContractIndex, _newLogicContract);
}
}
| 275,352 | 10,732 |
82e5399b514ed44b5c0d583040fa83ce5d2648b88f6bf73057296a0b09e72656
| 14,808 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/6a/6a8bcf0517522c15ee9e9f5fbff8a5451fca4612_Proxy.sol
| 3,677 | 13,272 |
pragma solidity ^0.6.0;
// SPDX-License-Identifier: MIT
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 ceil(uint a, uint m) internal pure returns (uint r) {
return (a + m - 1) / m * m;
}
}
contract Owned {
address payable public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable _newOwner) public onlyOwner {
owner = _newOwner;
emit OwnershipTransferred(msg.sender, _newOwner);
}
}
interface IToken {
function decimals() external view returns (uint256);
function transfer(address to, uint256 tokens) external returns (bool success);
function burnTokens(uint256 _amount) external;
function balanceOf(address tokenOwner) external view returns (uint256 balance);
function approve(address _spender, uint256 _amount) external returns (bool success);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface MetaStake {
function deposit(uint, uint) external;
function depositFor(uint,uint,address) external;
function withdraw(uint, uint) external;
function userInfo(uint, address) external view returns (uint, uint);
}
contract MetaswapLaunchpad is Owned {
using SafeMath for uint256;
bool public isPresaleOpen;
address public tokenAddress; // buy
uint256 public tokenDecimals = 18;
// address public _crypto = 0x55d398326f99059fF775485246999027B3197955; // USDT // sell
address public _crypto = 0x8d9f46183A23d81dcCc172C92bDb4553c1b67FFf; // testnet USDT // sell
uint256 public tokenRatePerEth = 0;
uint256 public tokenRatePercrypto = 0;
uint256 public rateDecimals = 0;
uint256 public minEthLimit = 1e17; // 0.1 BNB
uint256 public maxEthLimit = 10e18; // 10 BNB
uint256 public BUSDminEthLimit = 1e17; // 0.1 BNB
uint256 public BUSDmaxEthLimit = 10e18;
uint256 public soldTokens=0;
uint256 public intervalDays;
uint256 public endTime = 2 days;
bool public isClaimable = false;
bool public isWhitelisted = false;
bool public iscrypto = false;
uint256 public hardCap = 10 ether;
uint256 public BUSDhardCap = 10 ether;
uint256 public earnedCap =0;
uint256 public BUSDearnedCap =0;
uint256 public whitelistLength = 0;
address public Staker;
uint256 public currentPoolId = 0;
mapping(address => uint256) public usersInvestments;
mapping(address => uint256) public usersBUSDInvestments;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public whitelistedAddresses;
function startPresale(uint256 numberOfdays) external onlyOwner{
require(!isPresaleOpen, "Presale is open");
intervalDays = numberOfdays.mul(1 days);
endTime = block.timestamp.add(intervalDays);
isPresaleOpen = true;
isClaimable = false;
}
function closePresale() external onlyOwner{
require(isPresaleOpen, "Presale is not open yet or ended.");
isPresaleOpen = false;
}
function setTokenAddress(address token) external onlyOwner {
tokenAddress = token;
}
function setCurrentPoolId(uint256 _pid) external onlyOwner {
currentPoolId = _pid;
}
function setTokenDecimals(uint256 decimals) external onlyOwner {
tokenDecimals = decimals;
}
function setCryptoAddress(address token) external onlyOwner {
_crypto = token;
}
function setMinEthLimit(uint256 amount) external onlyOwner {
minEthLimit = amount;
}
function setBUSDMinEthLimit(uint256 amount) external onlyOwner {
BUSDminEthLimit = amount;
}
function setMaxEthLimit(uint256 amount) external onlyOwner {
maxEthLimit = amount;
}
function setBUSDMaxEthLimit(uint256 amount) external onlyOwner {
BUSDmaxEthLimit = amount;
}
function setTokenRatePerEth(uint256 rate) external onlyOwner {
tokenRatePerEth = rate;
}
function setTokenRatePercrypto(uint256 rateBUSD) external onlyOwner {
tokenRatePercrypto = rateBUSD;
}
function setRateDecimals(uint256 decimals) external onlyOwner {
rateDecimals = decimals;
}
function getUserInvestments(address user) public view returns (uint256){
return usersInvestments[user];
}
function getUserBUSDInvestments(address user) public view returns (uint256){
return usersBUSDInvestments[user];
}
function getUserClaimbale(address user) public view returns (uint256){
return balanceOf[user];
}
function addWhitelistedAddress(address _address, uint256 _allocation) external onlyOwner {
whitelistedAddresses[tokenAddress][_address] = _allocation;
}
function addMultipleWhitelistedAddresses(address[] calldata _addresses, uint256[] calldata _allocation) external onlyOwner {
for (uint i=0; i<_addresses.length; i++) {
whitelistLength = whitelistLength.add(1);
whitelistedAddresses[tokenAddress][_addresses[i]] = _allocation[i];
}
}
function removeWhitelistedAddress(address _address) external onlyOwner {
whitelistedAddresses[tokenAddress][_address] = 0;
whitelistLength = whitelistLength.sub(1);
}
receive() external payable{
uint256 amount = msg.value;
if(block.timestamp > endTime || earnedCap.add(amount) > hardCap)
isPresaleOpen = false;
require(isPresaleOpen, "Presale is not open.");
if(isWhitelisted){
require(whitelistedAddresses[tokenAddress][msg.sender] > 0, "you are not whitelisted");
require(whitelistedAddresses[tokenAddress][msg.sender] >= amount, "amount too high");
require(usersInvestments[msg.sender].add(amount) <= whitelistedAddresses[tokenAddress][msg.sender], "Maximum purchase cap hit");
}else{
require(usersInvestments[msg.sender].add(amount) <= maxEthLimit
&& usersInvestments[msg.sender].add(amount) >= minEthLimit,
"Installment Invalid.");
}
require(earnedCap.add(amount) <= hardCap,"Hard Cap Exceeds");
require((IToken(tokenAddress).balanceOf(address(this))).sub(soldTokens) > 0 ,"No Presale Funds left");
uint256 tokenAmount = getTokensPerEth(amount);
require((IToken(tokenAddress).balanceOf(address(this))).sub(soldTokens) >= tokenAmount ,"No Presale Funds left");
// require(msg.value),"Insufficient balance from User");
balanceOf[msg.sender] = balanceOf[msg.sender].add(tokenAmount);
soldTokens = soldTokens.add(tokenAmount);
usersInvestments[msg.sender] = usersInvestments[msg.sender].add(amount);
earnedCap = earnedCap.add(amount);
payable(owner).transfer(amount);
IToken(tokenAddress).approve(Staker,soldTokens);
}
function buyToken(uint256 amount) public{
if(block.timestamp > endTime || BUSDearnedCap.add(amount) > BUSDhardCap)
isPresaleOpen = false;
require(isPresaleOpen, "Presale is not open.");
if(isWhitelisted){
require(whitelistedAddresses[tokenAddress][msg.sender] > 0, "you are not whitelisted");
require(whitelistedAddresses[tokenAddress][msg.sender] >= amount, "amount too high");
require(usersBUSDInvestments[msg.sender].add(amount) <= whitelistedAddresses[tokenAddress][msg.sender], "Maximum purchase cap hit");
}else{
require(usersBUSDInvestments[msg.sender].add(amount) <= BUSDmaxEthLimit
&& usersBUSDInvestments[msg.sender].add(amount) >= BUSDminEthLimit,
"Installment Invalid.");
}
require(BUSDearnedCap.add(amount) <= BUSDhardCap,"Hard Cap Exceeds");
require((IToken(tokenAddress).balanceOf(address(this))).sub(soldTokens) > 0 ,"No Presale Funds left");
uint256 tokenAmount = getTokenPerCrypto(amount);
require((IToken(tokenAddress).balanceOf(address(this))).sub(soldTokens) >= tokenAmount ,"No Presale Funds left");
require(IToken(_crypto).transferFrom(msg.sender,owner, amount),"Insufficient balance from User");
balanceOf[msg.sender] = balanceOf[msg.sender].add(tokenAmount);
soldTokens = soldTokens.add(tokenAmount);
usersBUSDInvestments[msg.sender] = usersBUSDInvestments[msg.sender].add(amount);
BUSDearnedCap = BUSDearnedCap.add(amount);
IToken(tokenAddress).approve(Staker,soldTokens);
}
function claimTokens() public{
// require(!isPresaleOpen, "You cannot claim tokens until the presale is closed.");
// require(isClaimable, "You cannot claim tokens until the finalizeSale.");
require(balanceOf[msg.sender] > 0 , "No Tokens left !");
MetaStake(Staker).depositFor(currentPoolId,balanceOf[msg.sender],msg.sender);
balanceOf[msg.sender]=0;
}
function finalizeSale(address _staker) public onlyOwner{
isClaimable = !(isClaimable);
Staker = _staker;
IToken(tokenAddress).approve(Staker,soldTokens);
soldTokens = 0;
}
function approveContarct(address _staker,uint256 _amount) public onlyOwner {
Staker = _staker;
IToken(tokenAddress).approve(_staker,_amount);
}
function deposit(uint256 _pid,uint256 _amount) public onlyOwner{
MetaStake(Staker).depositFor(_pid,_amount,msg.sender);
}
function whitelistedSale() public onlyOwner{
isWhitelisted = !(isWhitelisted);
}
function setHardCap(uint256 _hardCap) public onlyOwner{
hardCap = _hardCap;
}
function setBUSDHardCap(uint256 _BUSDhardCap) public onlyOwner{
BUSDhardCap = _BUSDhardCap;
}
function getTokensPerEth(uint256 amount) public view returns(uint256) {
return amount.mul(tokenRatePerEth).div(10**(uint256(18).sub(tokenDecimals).add(rateDecimals)));
}
function getTokenPerCrypto(uint256 _amount) public view returns (uint256){
return _amount.mul(tokenRatePercrypto).div(10**(uint256(IToken(_crypto).decimals()).sub(uint256(IToken(tokenAddress).decimals()).add(rateDecimals))));
}
function withdrawBNB() public onlyOwner{
require(address(this).balance > 0 , "No Funds Left");
owner.transfer(address(this).balance);
}
function getUnsoldTokensBalance() public view returns(uint256) {
return IToken(tokenAddress).balanceOf(address(this));
}
function burnUnsoldTokens() external onlyOwner {
require(!isPresaleOpen, "You cannot burn tokens untitl the presale is closed.");
IToken(tokenAddress).burnTokens(IToken(tokenAddress).balanceOf(address(this)));
}
function getUnsoldTokens() external onlyOwner {
require(!isPresaleOpen, "You cannot get tokens until the presale is closed.");
soldTokens = 0;
IToken(tokenAddress).transfer(owner, (IToken(tokenAddress).balanceOf(address(this))).sub(soldTokens));
}
constructor(address _tokenAddress,
uint256 _tokenRatePerEth,
uint256 _tokenRatePercrypto,
uint256 _maxEthLimit,
uint256 _minEthLimit,
uint256 _BUSDmaxEthLimit,
uint256 _BUSDminEthLimit,
uint256 _hardCap,
uint256 _BUSDhardCap,
uint256 _poolId,
address _staker,
address _owner) public {
tokenAddress = _tokenAddress;
tokenRatePerEth = _tokenRatePerEth;
tokenRatePercrypto = _tokenRatePercrypto;
maxEthLimit = _maxEthLimit;
minEthLimit = _minEthLimit;
BUSDmaxEthLimit = _BUSDmaxEthLimit;
BUSDminEthLimit = _BUSDminEthLimit;
hardCap = _hardCap;
BUSDhardCap = _BUSDhardCap;
currentPoolId = _poolId;
Staker = _staker;
owner = payable(_owner);
}
}
contract Proxy is Owned {
mapping(address => address) public _presale;
function createPresale(address _tokenAddress,
uint256 _tokenRatePerEth,
uint256 _tokenRatePercrypto,
uint256 _maxEthLimit,
uint256 _minEthLimit,
uint256 _BUSDmaxEthLimit,
uint256 _BUSDminEthLimit,
uint256 _hardCap,
uint256 _BUSDhardCap,
uint256 _poolId,
address _staker) public onlyOwner {
_presale[_tokenAddress] = address(new MetaswapLaunchpad(_tokenAddress,_tokenRatePerEth,_tokenRatePercrypto,_maxEthLimit,_minEthLimit,_BUSDmaxEthLimit,_BUSDminEthLimit,_hardCap,_BUSDhardCap,_poolId,_staker,msg.sender));
}
function getPresale(address _token) public view returns (address){
return _presale[_token];
}
}
| 123,488 | 10,733 |
578ebc08b3b4e296742c405d05ba6f64cad2590d12fea11fc17e68dccb77e97f
| 26,136 |
.sol
|
Solidity
| false |
287303317
|
GrapFinance/grap-protocol
|
34df44b6bacadb3bfa8782671307dc57788df64e
|
contracts/distribution/GRAPYFFI_UNIV_Pool.sol
| 3,915 | 14,305 |
pragma solidity ^0.5.0;
// File: @openzeppelin/contracts/math/Math.sol
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
// File: @openzeppelin/contracts/math/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// File: @openzeppelin/contracts/GSN/Context.sol
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () 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;
}
}
// File: @openzeppelin/contracts/ownership/Ownable.sol
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;
}
}
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: @openzeppelin/contracts/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// File: contracts/IRewardDistributionRecipient.sol
contract IRewardDistributionRecipient is Ownable {
address public rewardDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardDistribution() {
require(_msgSender() == rewardDistribution, "Caller is not reward distribution");
_;
}
function setRewardDistribution(address _rewardDistribution)
external
onlyOwner
{
rewardDistribution = _rewardDistribution;
}
}
// File: contracts/CurveRewards.sol
interface GRAP {
function grapsScalingFactor() external returns (uint256);
}
contract LPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public yffi_grap_univ = IERC20(0x79A3919d86e90Eb101C5fBbcaDB06B546667B323);
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
yffi_grap_univ.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
yffi_grap_univ.safeTransfer(msg.sender, amount);
}
}
contract GRAPYFFI_UNIV_Pool is LPTokenWrapper, IRewardDistributionRecipient {
IERC20 public grap = IERC20(0xC8D2AB2a6FdEbC25432E54941cb85b55b9f152dB);
uint256 public constant DURATION = 625000; // ~7 1/4 days
uint256 public starttime = 1598400000; // 2020-08-20 00:00:00 (UTC +00:00)
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier checkStart() {
require(block.timestamp >= starttime,"not start");
_;
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
// stake visibility is public as overriding LPTokenWrapper's stake() function
function stake(uint256 amount) public updateReward(msg.sender) checkStart {
require(amount > 0, "Cannot stake 0");
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkStart {
require(amount > 0, "Cannot withdraw 0");
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) checkStart {
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
uint256 scalingFactor = GRAP(address(grap)).grapsScalingFactor();
uint256 trueReward = reward.mul(scalingFactor).div(10**18);
grap.safeTransfer(msg.sender, trueReward);
emit RewardPaid(msg.sender, trueReward);
}
}
function notifyRewardAmount(uint256 reward)
external
onlyRewardDistribution
updateReward(address(0))
{
if (block.timestamp > starttime) {
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(DURATION);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(DURATION);
}
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(DURATION);
emit RewardAdded(reward);
} else {
rewardRate = reward.div(DURATION);
lastUpdateTime = starttime;
periodFinish = starttime.add(DURATION);
emit RewardAdded(reward);
}
// avoid overflow to lock assets
uint256 check = DURATION.mul(rewardRate).mul(1e18);
}
}
| 334,291 | 10,734 |
90a0ce0d02ff38b69651264cfd08b853ff5b9edf68c84cbba8969bd83cc52ec7
| 18,094 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x2ce1cb7f7b8aa04dc78cf1435192106bc4c394bf.sol
| 4,849 | 17,666 |
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 amount) public pure returns (uint rankFundsFee) {
rankFundsFee = amount * RANK_FUNDS_PERCENT / 10000;
}
function calcInviterBenefit(uint amount) public pure returns (uint invitationFee) {
invitationFee = amount * INVITER_BENEFIT_PERCENT / 10000;
}
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 inviterBenefit = calcInviterBenefit(betAmount);
if (inviter.send(inviterBenefit)) {
emit InviterBenefit(inviter, gambler, inviterBenefit, betAmount);
}
}
}
function transferCryptoTycoonsFee(uint amount) internal {
uint jackpotFee = calcJackpotFee(amount);
uint rankFundFee = calcRankFundsFee(amount);
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,785 | 10,735 |
847a5650c7a2ab92c0c8bfd1e8bbae5da57d84d324986a23a419c96cda388b24
| 13,010 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/PZMTokenByAndSellConcept.sol
| 3,370 | 12,206 |
pragma solidity ^0.4.25;
library Address {
function toAddress(bytes source) internal pure returns(address addr) {
assembly { addr := mload(add(source,0x14)) }
return addr;
}
function isNotContract(address addr) internal view returns(bool) {
uint length;
assembly { length := extcodesize(addr) }
return length == 0;
}
}
contract PZMTokenByAndSellConcept {
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 = "PZM Token";
string public symbol = "PZMT";
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;
}
}
| 195,917 | 10,736 |
2bc0d0753a9b6ec5357d5a9e98783098b615a947a0d1150d22aab6a0e942bfc4
| 13,118 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x8495312ec8221366de50367a1188e6b82f07576a.sol
| 3,368 | 12,199 |
pragma solidity ^0.4.25;
library Address {
function toAddress(bytes source) internal pure returns(address addr) {
assembly { addr := mload(add(source,0x14)) }
return addr;
}
function isNotContract(address addr) internal view returns(bool) {
uint length;
assembly { length := extcodesize(addr) }
return length == 0;
}
}
contract KTM_Token_Exchange {
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 = "KTM Token";
string public symbol = "KTM";
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;
}
}
| 339,439 | 10,737 |
f03ce68ec9c0a6ac03f10b97495e58e67c43feabf6181e4ef0eed07b7a7cc60c
| 21,331 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x14798b51fe34812502dfff1a26942fd232f5e454.sol
| 5,246 | 18,424 |
pragma solidity ^0.4.21;
contract EIP20Interface {
function name() public view returns (string);
function symbol() public view returns (string);
function decimals() public view returns (uint8);
function totalSupply() public view returns (uint256);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) public view returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
// solhint-disable-next-line no-simple-event-func-name
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract EIP20 is EIP20Interface {
uint256 constant private MAX_UINT256 = 2**256 - 1;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
string public tokenName; //fancy name: eg Simon Bucks
uint8 public tokenDecimals; //How many decimals to show.
string public tokenSymbol; //An identifier: eg SBX
uint256 public tokenTotalSupply;
constructor(uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol) public {
balances[msg.sender] = _initialAmount; // Give the creator all initial tokens
tokenTotalSupply = _initialAmount; // Update total supply
tokenName = _tokenName; // Set the name for display purposes
tokenDecimals = _decimalUnits; // Amount of decimals for display purposes
tokenSymbol = _tokenSymbol; // Set the symbol for display purposes
}
function name() public view returns (string) {
return tokenName;
}
function symbol() public view returns (string) {
return tokenSymbol;
}
function decimals() public view returns (uint8) {
return tokenDecimals;
}
function totalSupply() public view returns (uint256) {
return tokenTotalSupply;
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
uint256 allowance = allowed[_from][msg.sender];
require(balances[_from] >= _value && allowance >= _value);
balances[_to] += _value;
balances[_from] -= _value;
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] -= _value;
}
emit Transfer(_from, _to, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract TimeBankToken is EIP20 {
using SafeMath for uint;
struct Vesting {
uint256 startTime; // vesting start time
uint256 initReleaseAmount;
uint256 amount;
uint256 interval; // release N% of amount each interval.
uint256 periods; // count of periods
uint256 withdrawed; // already used amount of released part
}
mapping (address => Vesting[]) vestings;
address[] managerList;
mapping (address => bool) managers;
mapping (bytes32 => mapping (address => bool)) confirms;
uint majorityThreshold;
uint managementThreshold;
address coinbase;
address master;
bool public paused;
function checkAddress(address _addr) internal pure returns (bool) {
return _addr != address(0);
}
// 1 with 28 zeros
constructor(address _master, address[] _managers, uint _majorityThreshold, uint _managementThreshold) EIP20(10000000000000000000000000000, "Time Bank Token", 18, "TBT") public {
require(checkAddress(_master));
require(_managers.length >= _majorityThreshold);
require(_managers.length >= _managementThreshold);
paused = false;
master = _master;
coinbase = msg.sender;
majorityThreshold = _majorityThreshold;
managementThreshold = _managementThreshold;
for (uint i=0; i<_managers.length; i++) {
require(checkAddress(_managers[i]));
managers[_managers[i]] = true;
}
managerList = _managers;
// initial batch operations
// internalPresaleVesting(0x0095F9DffeE386B650230eD3eC28891c1053aBE0, 10000, 60, 120, 240);
// internalPresaleVesting(0x00D4fC2CC18B96c44D9755afB6D4e6804cF827ee, 20000, 60, 120, 240);
// internalPresale(0x0092E41D42E834705fd07c9136Fd0b1028226bE3, 30000);
}
function pause() public isMaster isNotPaused {
require(isEnoughConfirmed(msg.data, 1));
paused = true;
}
function resume() public isMaster isPaused {
require(isEnoughConfirmed(msg.data, 1));
paused = false;
}
modifier isPaused {
require(paused == true);
_;
}
modifier isNotPaused {
require(paused == false);
_;
}
modifier isManager {
require(managers[msg.sender]);
_;
}
modifier isMaster {
require(msg.sender == master);
_;
}
modifier isNotCoinbase {
require(msg.sender != coinbase);
_;
}
function managersCount() public view returns (uint) {
return managerList.length;
}
function isAddressManager(address _to) public view returns (bool) {
return managers[_to];
}
function getMajorityThreshold() public view returns (uint) {
return majorityThreshold;
}
event MajorityThresholdChanged(uint oldThreshold, uint newThreshold);
event ReplaceManager(address oldAddr, address newAddr);
event RemoveManager(address manager);
event AddManager(address manager);
function setMajorityThreshold(uint _threshold) public isMaster isNotPaused {
require(_threshold > 0);
require(isEnoughConfirmed(msg.data, managementThreshold));
uint oldThreshold = majorityThreshold;
majorityThreshold = _threshold;
removeConfirm(msg.data);
emit MajorityThresholdChanged(oldThreshold, majorityThreshold);
}
function replaceManager(address _old, address _new) public isMaster isNotPaused {
require(checkAddress(_old));
require(checkAddress(_new));
require(isEnoughConfirmed(msg.data, managementThreshold));
internalRemoveManager(_old);
internalAddManager(_new);
rebuildManagerList();
removeConfirm(msg.data);
emit ReplaceManager(_old, _new);
}
function removeManager(address _manager) public isMaster isNotPaused {
require(checkAddress(_manager));
require(isEnoughConfirmed(msg.data, managementThreshold));
require(managerList.length > managementThreshold);
internalRemoveManager(_manager);
rebuildManagerList();
removeConfirm(msg.data);
emit RemoveManager(_manager);
}
function internalRemoveManager(address _manager) internal {
require(checkAddress(_manager));
managers[_manager] = false;
}
function addManager(address _manager) public isMaster isNotPaused {
require(checkAddress(_manager));
require(isEnoughConfirmed(msg.data, managementThreshold));
internalAddManager(_manager);
rebuildManagerList();
removeConfirm(msg.data);
emit AddManager(_manager);
}
function internalAddManager(address _manager) internal {
require(checkAddress(_manager));
managers[_manager] = true;
managerList.push(_manager);
}
mapping (address => bool) checked;
function rebuildManagerList() internal {
address[] memory res = new address[](managerList.length);
for (uint k=0; k<managerList.length; k++) {
checked[managerList[k]] = false;
}
uint j=0;
for (uint i=0; i<managerList.length; i++) {
address manager = managerList[i];
if (managers[manager] && checked[manager] == false) {
res[j] = manager;
checked[manager] = true;
j++;
}
}
managerList = res;
managerList.length = j;
}
function checkData(bytes data) internal pure returns (bool) {
return data.length != 0;
}
event Confirm(address manager, bytes data);
event Revoke(address manager, bytes data);
function confirm(bytes data) external isManager {
checkData(data);
bytes32 op = keccak256(data);
if (confirms[op][msg.sender] == false) {
confirms[op][msg.sender] = true;
}
emit Confirm(msg.sender, data);
}
function revoke(bytes data) external isManager {
checkData(data);
bytes32 op = keccak256(data);
if (confirms[op][msg.sender] == true) {
confirms[op][msg.sender] = false;
}
emit Revoke(msg.sender, data);
}
function isConfirmed(bytes data) public view isManager returns (bool) {
bytes32 op = keccak256(data);
return confirms[op][msg.sender];
}
function isConfirmedBy(bytes data, address manager) public view returns (bool) {
bytes32 op = keccak256(data);
return confirms[op][manager];
}
function isMajorityConfirmed(bytes data) public view returns (bool) {
return isEnoughConfirmed(data, majorityThreshold);
}
function isEnoughConfirmed(bytes data, uint count) internal view returns (bool) {
bytes32 op = keccak256(data);
uint confirmsCount = 0;
for (uint i=0; i<managerList.length; i++) {
if (confirms[op][managerList[i]] == true) {
confirmsCount = confirmsCount.add(1);
}
}
return confirmsCount >= count;
}
function removeConfirm(bytes data) internal {
bytes32 op = keccak256(data);
for (uint i=0; i<managerList.length; i++) {
confirms[op][managerList[i]] = false;
}
}
function presaleVesting(address _to, uint256 _startTime, uint256 _initReleaseAmount, uint256 _amount, uint256 _interval, uint256 _periods) public isManager isNotPaused {
checkAddress(_to);
require(isMajorityConfirmed(msg.data));
internalPresaleVesting(_to, _startTime, _initReleaseAmount, _amount, _interval, _periods);
removeConfirm(msg.data);
}
function batchPresaleVesting(address[] _to, uint256[] _startTime, uint256[] _initReleaseAmount, uint256[] _amount, uint256[] _interval, uint256[] _periods) public isManager isNotPaused {
require(isMajorityConfirmed(msg.data));
for (uint i=0; i<_to.length; i++) {
internalPresaleVesting(_to[i], _startTime[i], _initReleaseAmount[i], _amount[i], _interval[i], _periods[i]);
}
removeConfirm(msg.data);
}
function internalPresaleVesting(address _to, uint256 _startTime, uint256 _initReleaseAmount, uint256 _amount, uint256 _interval, uint256 _periods) internal {
require(balances[coinbase] >= _amount);
require(_initReleaseAmount <= _amount);
require(checkAddress(_to));
vestings[_to].push(Vesting(_startTime, _initReleaseAmount, _amount, _interval, _periods, 0));
balances[coinbase] = balances[coinbase].sub(_amount);
emit PresaleVesting(_to, _startTime, _amount, _interval, _periods);
}
function presale(address _to, uint256 _value) public isManager isNotPaused {
require(isMajorityConfirmed(msg.data));
internalPresale(_to, _value);
removeConfirm(msg.data);
}
function batchPresale(address[] _to, uint256[] _amount) public isManager isNotPaused {
require(isMajorityConfirmed(msg.data));
for (uint i=0; i<_to.length; i++) {
internalPresale(_to[i], _amount[i]);
}
removeConfirm(msg.data);
}
function internalPresale(address _to, uint256 _value) internal {
require(balances[coinbase] >= _value);
require(checkAddress(_to));
balances[_to] = balances[_to].add(_value);
balances[coinbase] = balances[coinbase].sub(_value);
emit Presale(_to, _value);
}
event Presale(address indexed to, uint256 value);
event PresaleVesting(address indexed to, uint256 startTime, uint256 amount, uint256 interval, uint256 periods);
function vestingFunc(uint256 _currentTime, uint256 _startTime, uint256 _initReleaseAmount, uint256 _amount, uint256 _interval, uint256 _periods) public pure returns (uint256) {
if (_currentTime < _startTime) {
return 0;
}
uint256 t = _currentTime.sub(_startTime);
uint256 end = _periods.mul(_interval);
if (t >= end) {
return _amount;
}
uint256 i_amount = _amount.sub(_initReleaseAmount).div(_periods);
uint256 i = t.div(_interval);
return i_amount.mul(i).add(_initReleaseAmount);
}
function queryWithdrawed(uint _idx) public view returns (uint256) {
return vestings[msg.sender][_idx].withdrawed;
}
function queryVestingRemain(uint256 _currentTime, uint _idx) public view returns (uint256) {
uint256 released = vestingFunc(_currentTime,
vestings[msg.sender][_idx].startTime, vestings[msg.sender][_idx].initReleaseAmount, vestings[msg.sender][_idx].amount,
vestings[msg.sender][_idx].interval, vestings[msg.sender][_idx].periods);
return released.sub(vestings[msg.sender][_idx].withdrawed);
}
function vestingReleased(uint256 _startTime, uint256 _initReleaseAmount, uint256 _amount, uint256 _interval, uint256 _periods) internal view returns (uint256) {
return vestingFunc(now, _startTime, _initReleaseAmount, _amount, _interval, _periods);
}
function withdrawVestings(address _to) internal {
uint256 sum = 0;
for (uint i=0; i<vestings[_to].length; i++) {
if (vestings[_to][i].amount == vestings[_to][i].withdrawed) {
continue;
}
uint256 released = vestingReleased(vestings[_to][i].startTime, vestings[_to][i].initReleaseAmount, vestings[_to][i].amount,
vestings[_to][i].interval, vestings[_to][i].periods);
uint256 remain = released.sub(vestings[_to][i].withdrawed);
if (remain >= 0) {
vestings[_to][i].withdrawed = released;
sum = sum.add(remain);
}
}
balances[_to] = balances[_to].add(sum);
}
function vestingsBalance(address _to) public view returns (uint256) {
uint256 sum = 0;
for (uint i=0; i<vestings[_to].length; i++) {
sum = sum.add(vestings[_to][i].amount.sub(vestings[_to][i].withdrawed));
}
return sum;
}
function vestingsReleasedRemain(address _to) internal view returns (uint256) {
uint256 sum = 0;
for (uint i=0; i<vestings[_to].length; i++) {
uint256 released = vestingReleased(vestings[_to][i].startTime, vestings[_to][i].initReleaseAmount, vestings[_to][i].amount,
vestings[_to][i].interval, vestings[_to][i].periods);
sum = sum.add(released.sub(vestings[_to][i].withdrawed));
}
return sum;
}
function balanceOf(address _to) public view returns (uint256) {
uint256 vbalance = vestingsBalance(_to);
return vbalance.add(super.balanceOf(_to));
}
function vestingsRemainBalance(address _to) internal view returns (uint256) {
return vestingsReleasedRemain(_to).add(super.balanceOf(_to));
}
function transfer(address _to, uint256 _value) public isNotCoinbase isNotPaused returns (bool) {
checkAddress(_to);
uint256 remain = vestingsRemainBalance(msg.sender);
require(remain >= _value);
withdrawVestings(msg.sender);
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public isNotPaused returns (bool) {
checkAddress(_from);
checkAddress(_to);
uint256 remain = vestingsRemainBalance(_from);
require(remain >= _value);
withdrawVestings(_from);
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public isNotCoinbase isNotPaused returns (bool) {
checkAddress(_spender);
uint256 remain = vestingsRemainBalance(msg.sender);
require(remain >= _value);
withdrawVestings(msg.sender);
return super.approve(_spender, _value);
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return super.allowance(_owner, _spender);
}
}
| 202,719 | 10,738 |
cf3797937615ada653f787d713070cd034038f136913906d1a625937dc06727f
| 14,850 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x639e68de58fcbbac6302d5a6eeae756c43eef242.sol
| 3,222 | 11,059 |
pragma solidity 0.4.25;
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 != owner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
//sorry limited to 32 characters
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
// make sure it doesnt start with or end with space
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
// create a bool to track if we have a non number character
bool _hasNonNumber;
// convert & check
for (uint256 i = 0; i < _length; i++)
{
// if its uppercase A-Z
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
// convert to lower case a-z
_temp[i] = byte(uint(_temp[i]) + 32);
// we have a non number
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(// require character is a space
_temp[i] == 0x20 ||
// OR lowercase a-z
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
// or 0-9
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters");
// make sure theres not 2x spaces in a row
if (_temp[i] == 0x20)
require(_temp[i+1] != 0x20, "string cannot contain consecutive spaces");
// see if we have a character other than a number
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
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 CelebrityGame is Ownable {
using SafeMath for *;
using NameFilter for string;
string constant public gameName = "Celebrity Game";
// fired whenever a card is created
event LogNewCard(string name, uint256 id);
// fired whenever a player is registered
event LogNewPlayer(string name, uint256 id);
//just for isStartEnable modifier
bool private isStart = false;
uint256 private roundId = 0;
struct Card {
bytes32 name; // card owner name
uint256 fame; // The number of times CARDS were liked
uint256 fameValue; // The charge for the current card to be liked once
uint256 notorious; // The number of times CARDS were disliked
uint256 notoriousValue; // The charge for the current card to be disliked once
}
struct CardForPlayer {
uint256 likeCount; // The number of times the player likes it
uint256 dislikeCount; // The number of times the player disliked it
}
struct CardWinner {
bytes32 likeWinner;
bytes32 dislikeWinner;
}
Card[] public cards;
bytes32[] public players;
mapping (uint256 => mapping (uint256 => mapping (uint256 => CardForPlayer))) public playerCard; // returns cards of this player like or dislike by playerId and roundId and cardId
mapping (uint256 => mapping (uint256 => CardWinner)) public cardWinnerMap; // (roundId => (cardId => winner)) returns winner by roundId and cardId
mapping (uint256 => Card[]) public rounCardMap; // returns Card info by roundId
mapping (bytes32 => uint256) private plyNameXId; // (playerName => Id) returns playerId by playerName
mapping (bytes32 => uint256) private cardNameXId; // (cardName => Id) returns cardId by cardName
mapping (bytes32 => bool) private cardIsReg; // (cardName => cardCount) returns cardCount by cardNamejust for createCard function
mapping (bytes32 => bool) private playerIsReg; // (playerName => isRegister) returns registerInfo by playerName, just for registerPlayer funciton
mapping (uint256 => bool) private cardIdIsReg; // (cardId => card info) returns card info by cardId
mapping (uint256 => bool) private playerIdIsReg; // (playerId => id) returns player index of players by playerId
mapping (uint256 => uint256) private cardIdXSeq;
mapping (uint256 => uint256) private playerIdXSeq;
modifier isStartEnable {
require(isStart == true);
_;
}
constructor() public {
string[8] memory names= ["SatoshiNakamoto","CZ","HeYi","LiXiaolai","GuoHongcai","VitalikButerin","StarXu","ByteMaster"];
uint256[8] memory _ids = [uint256(183946248739),536269148721,762415028463,432184367532,398234673241,264398721023,464325189620,217546321806];
for (uint i = 0; i < 8; i++){
string memory _nameString = names[i];
uint256 _id = _ids[i];
bytes32 _name = _nameString.nameFilter();
require(cardIsReg[_name] == false);
uint256 _seq = cards.push(Card(_name, 1, 1000, 1, 1000)) - 1;
cardIdXSeq[_id] = _seq;
cardNameXId[_name] = _id;
cardIsReg[_name] = true;
cardIdIsReg[_id] = true;
}
}
function createCard(string _nameString, uint256 _id) public onlyOwner() {
require(keccak256(abi.encodePacked(_name)) != keccak256(abi.encodePacked("")));
bytes32 _name = _nameString.nameFilter();
require(cardIsReg[_name] == false);
uint256 _seq = cards.push(Card(_name, 1, 1000, 1, 1000)) - 1;
cardIdXSeq[_id] = _seq;
cardNameXId[_name] = _id;
cardIsReg[_name] = true;
cardIdIsReg[_id] = true;
emit LogNewCard(_nameString, _id);
}
function registerPlayer(string _nameString, uint256 _id) external {
require(keccak256(abi.encodePacked(_name)) != keccak256(abi.encodePacked("")));
bytes32 _name = _nameString.nameFilter();
require(playerIsReg[_name] == false);
uint256 _seq = players.push(_name) - 1;
playerIdXSeq[_id] = _seq;
plyNameXId[_name] = _id;
playerIsReg[_name] = true;
playerIdIsReg[_id] = true;
emit LogNewPlayer(_nameString, _id);
}
function likeCelebrity(uint256 _cardId, uint256 _playerId) external isStartEnable {
require(cardIdIsReg[_cardId] == true, "sorry create this card first");
require(playerIdIsReg[_playerId] == true, "sorry register the player name first");
Card storage queryCard = cards[cardIdXSeq[_cardId]];
queryCard.fame = queryCard.fame.add(1);
queryCard.fameValue = queryCard.fameValue.add(queryCard.fameValue / 100*1000);
playerCard[_playerId][roundId][_cardId].likeCount == (playerCard[_playerId][roundId][_cardId].likeCount).add(1);
cardWinnerMap[roundId][_cardId].likeWinner = players[playerIdXSeq[_playerId]];
}
function dislikeCelebrity(uint256 _cardId, uint256 _playerId) external isStartEnable {
require(cardIdIsReg[_cardId] == true, "sorry create this card first");
require(playerIdIsReg[_playerId] == true, "sorry register the player name first");
Card storage queryCard = cards[cardIdXSeq[_cardId]];
queryCard.notorious = queryCard.notorious.add(1);
queryCard.notoriousValue = queryCard.notoriousValue.add(queryCard.notoriousValue / 100*1000);
playerCard[_playerId][roundId][_cardId].dislikeCount == (playerCard[_playerId][roundId][_cardId].dislikeCount).add(1);
cardWinnerMap[roundId][_cardId].dislikeWinner = players[playerIdXSeq[_playerId]];
}
function reset(uint256 _id) external onlyOwner() {
require(isStart == false);
Card storage queryCard = cards[cardIdXSeq[_id]];
queryCard.fame = 1;
queryCard.fameValue = 1000;
queryCard.notorious = 1;
queryCard.notoriousValue = 1000;
}
function gameStart() external onlyOwner() {
isStart = true;
roundId = roundId.add(1);
}
function gameEnd() external onlyOwner() {
isStart = false;
rounCardMap[roundId] = cards;
}
function getCardsCount() public view returns(uint256) {
return cards.length;
}
function getCardId(string _nameString) public view returns(uint256) {
bytes32 _name = _nameString.nameFilter();
require(cardIsReg[_name] == true, "sorry create this card first");
return cardNameXId[_name];
}
function getPlayerId(string _nameString) public view returns(uint256) {
bytes32 _name = _nameString.nameFilter();
require(playerIsReg[_name] == true, "sorry register the player name first");
return plyNameXId[_name];
}
function getPlayerBetCount(string _playerName, uint256 _roundId, string _cardName) public view returns(uint256 likeCount, uint256 dislikeCount) {
bytes32 _cardNameByte = _cardName.nameFilter();
require(cardIsReg[_cardNameByte] == false);
bytes32 _playerNameByte = _playerName.nameFilter();
require(playerIsReg[_playerNameByte] == false);
return (playerCard[plyNameXId[_playerNameByte]][_roundId][cardNameXId[_cardNameByte]].likeCount, playerCard[plyNameXId[_playerNameByte]][_roundId][cardNameXId[_cardNameByte]].dislikeCount);
}
}
| 203,034 | 10,739 |
417b8aedcff853f20328b259bdff05506c6186feeaddfebc1518fcd4c7b4e6a4
| 11,573 |
.sol
|
Solidity
| false |
496851308
|
kmbarry1/fund-eq-of-dai-certora
|
23dfb07ee4904fc0701f96ece3df89b4ed6eda69
|
Vat.sol
| 3,660 | 11,507 |
// SPDX-License-Identifier: AGPL-3.0-or-later
/// vat.sol -- Dai CDP database
// Note: this is a somewhat updated version from that on Ethereum mainnet,
// representing an intermediate product during preparation for deployment of
// MCD on other domains. See https://github.com/makerdao/xdomain-dss. It is not
// recommended to use or deploy this version. This repo is for pedagogical
// purposes only.
// 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.13;
contract Vat {
// --- Data ---
mapping (address => uint256) public wards;
mapping(address => mapping (address => uint256)) public can;
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; // Active Flag
// --- Events ---
event Rely(address indexed usr);
event Deny(address indexed usr);
event Init(bytes32 indexed ilk);
event File(bytes32 indexed what, uint256 data);
event File(bytes32 indexed ilk, bytes32 indexed what, uint256 data);
event Cage();
event Hope(address indexed from, address indexed to);
event Nope(address indexed from, address indexed to);
event Slip(bytes32 indexed ilk, address indexed usr, int256 wad);
event Flux(bytes32 indexed ilk, address indexed src, address indexed dst, uint256 wad);
event Move(address indexed src, address indexed dst, uint256 rad);
event Frob(bytes32 indexed i, address indexed u, address v, address w, int256 dink, int256 dart);
event Fork(bytes32 indexed ilk, address indexed src, address indexed dst, int256 dink, int256 dart);
event Grab(bytes32 indexed i, address indexed u, address v, address w, int256 dink, int256 dart);
event Heal(address indexed u, uint256 rad);
event Suck(address indexed u, address indexed v, uint256 rad);
event Fold(bytes32 indexed i, address indexed u, int256 rate);
modifier auth {
require(wards[msg.sender] == 1, "Vat/not-authorized");
_;
}
function wish(address bit, address usr) internal view returns (bool) {
return either(bit == usr, can[bit][usr] == 1);
}
// --- Init ---
constructor() {
wards[msg.sender] = 1;
live = 1;
emit Rely(msg.sender);
}
// --- Math ---
function _add(uint256 x, int256 y) internal pure returns (uint256 z) {
unchecked {
z = x + uint256(y);
}
require(y >= 0 || z <= x);
require(y <= 0 || z >= x);
}
function _sub(uint256 x, int256 y) internal pure returns (uint256 z) {
unchecked {
z = x - uint256(y);
}
require(y <= 0 || z <= x);
require(y >= 0 || z >= x);
}
function _int256(uint256 x) internal pure returns (int256 y) {
require((y = int256(x)) >= 0);
}
// --- Administration ---
function rely(address usr) external auth {
require(live == 1, "Vat/not-live");
wards[usr] = 1;
emit Rely(usr);
}
function deny(address usr) external auth {
require(live == 1, "Vat/not-live");
wards[usr] = 0;
emit Deny(usr);
}
function init(bytes32 ilk) external auth {
require(ilks[ilk].rate == 0, "Vat/ilk-already-init");
ilks[ilk].rate = 10 ** 27;
emit Init(ilk);
}
function file(bytes32 what, uint256 data) external auth {
require(live == 1, "Vat/not-live");
if (what == "Line") Line = data;
else revert("Vat/file-unrecognized-param");
emit File(what, data);
}
function file(bytes32 ilk, bytes32 what, uint256 data) external 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");
emit File(ilk, what, data);
}
function cage() external auth {
live = 0;
emit Cage();
}
// --- Structs getters ---
function Art(bytes32 ilk) external view returns (uint256 Art_) {
Art_ = ilks[ilk].Art;
}
function rate(bytes32 ilk) external view returns (uint256 rate_) {
rate_ = ilks[ilk].rate;
}
function spot(bytes32 ilk) external view returns (uint256 spot_) {
spot_ = ilks[ilk].spot;
}
function line(bytes32 ilk) external view returns (uint256 line_) {
line_ = ilks[ilk].line;
}
function dust(bytes32 ilk) external view returns (uint256 dust_) {
dust_ = ilks[ilk].dust;
}
function ink(bytes32 ilk, address urn) external view returns (uint256 ink_) {
ink_ = urns[ilk][urn].ink;
}
function art(bytes32 ilk, address urn) external view returns (uint256 art_) {
art_ = urns[ilk][urn].art;
}
// --- Allowance ---
function hope(address usr) external {
can[msg.sender][usr] = 1;
emit Hope(msg.sender, usr);
}
function nope(address usr) external {
can[msg.sender][usr] = 0;
emit Nope(msg.sender, usr);
}
// --- Fungibility ---
function slip(bytes32 ilk, address usr, int256 wad) external auth {
gem[ilk][usr] = _add(gem[ilk][usr], wad);
emit Slip(ilk, usr, wad);
}
function flux(bytes32 ilk, address src, address dst, uint256 wad) external {
require(wish(src, msg.sender), "Vat/not-allowed");
gem[ilk][src] = gem[ilk][src] - wad;
gem[ilk][dst] = gem[ilk][dst] + wad;
emit Flux(ilk, src, dst, wad);
}
function move(address src, address dst, uint256 rad) external {
require(wish(src, msg.sender), "Vat/not-allowed");
dai[src] = dai[src] - rad;
dai[dst] = dai[dst] + rad;
emit Move(src, dst, rad);
}
function either(bool x, bool y) internal pure returns (bool z) {
assembly{ z := or(x, y)}
}
function both(bool x, bool y) internal pure returns (bool z) {
assembly{ z := and(x, y)}
}
// --- CDP Manipulation ---
function frob(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external {
// 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);
int256 dtab = _int256(ilk.rate) * dart;
uint256 tab = ilk.rate * urn.art;
debt = _add(debt, dtab);
// either debt has decreased, or debt ceilings are not exceeded
require(either(dart <= 0, both(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 <= 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;
emit Frob(i, u, v, w, dink, dart);
}
// --- CDP Fungibility ---
function fork(bytes32 ilk, address src, address dst, int256 dink, int256 dart) external {
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);
uint256 utab = u.art * i.rate;
uint256 vtab = 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 <= u.ink * i.spot, "Vat/not-safe-src");
require(vtab <= 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");
emit Fork(ilk, src, dst, dink, dart);
}
// --- CDP Confiscation ---
function grab(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external 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);
int256 dtab = _int256(ilk.rate) * dart;
gem[i][v] = _sub(gem[i][v], dink);
sin[w] = _sub(sin[w], dtab);
vice = _sub(vice, dtab);
emit Grab(i, u, v, w, dink, dart);
}
// --- Settlement ---
function heal(uint256 rad) external {
address u = msg.sender;
sin[u] = sin[u] - rad;
dai[u] = dai[u] - rad;
vice = vice - rad;
debt = debt - rad;
emit Heal(msg.sender, rad);
}
function suck(address u, address v, uint256 rad) external auth {
sin[u] = sin[u] + rad;
dai[v] = dai[v] + rad;
vice = vice + rad;
debt = debt + rad;
emit Suck(u, v, rad);
}
// --- Rates ---
function fold(bytes32 i, address u, int256 rate_) external auth {
require(live == 1, "Vat/not-live");
Ilk storage ilk = ilks[i];
ilk.rate = _add(ilk.rate, rate_);
int256 rad = _int256(ilk.Art) * rate_;
dai[u] = _add(dai[u], rad);
debt = _add(debt, rad);
emit Fold(i, u, rate_);
}
}
| 334,382 | 10,740 |
b492f83771865685e2a722571a1af48e5fcc398a18ed4711446742c3efe6f35d
| 36,019 |
.sol
|
Solidity
| false |
303732004
|
makerdao/deployed-collateral-contracts
|
6a1811ab2aa6dc9a2c54cc1497fed4ed9370000c
|
src/greenlit/UMA/UMA.sol
| 4,625 | 18,224 |
// https://etherscan.io/address/0x04Fa0d235C4abf4BcF4787aF4CF447DE572eF828#code
pragma solidity ^0.5.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 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 Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library Arrays {
function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
if (array.length == 0) {
return 0;
}
uint256 low = 0;
uint256 high = array.length;
while (low < high) {
uint256 mid = Math.average(low, high);
// Note that mid will always be strictly less than high (i.e. it will be a valid array index)
// because Math.average rounds down (it does integer division with truncation).
if (array[mid] > element) {
high = mid;
} else {
low = mid + 1;
}
}
// At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
if (low > 0 && array[low - 1] == element) {
return low - 1;
} else {
return low;
}
}
}
library Counters {
using SafeMath for uint256;
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
contract ERC20Snapshot is ERC20 {
using SafeMath for uint256;
using Arrays for uint256[];
using Counters for Counters.Counter;
// Snapshot struct, but that would impede usage of functions that work on an array.
struct Snapshots {
uint256[] ids;
uint256[] values;
}
mapping (address => Snapshots) private _accountBalanceSnapshots;
Snapshots private _totalSupplySnapshots;
// Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
Counters.Counter private _currentSnapshotId;
event Snapshot(uint256 id);
// when required, but is also flexible enough that it allows for e.g. daily snapshots.
function snapshot() public returns (uint256) {
_currentSnapshotId.increment();
uint256 currentId = _currentSnapshotId.current();
emit Snapshot(currentId);
return currentId;
}
function balanceOfAt(address account, uint256 snapshotId) public view returns (uint256) {
(bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);
return snapshotted ? value : balanceOf(account);
}
function totalSupplyAt(uint256 snapshotId) public view returns(uint256) {
(bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots);
return snapshotted ? value : totalSupply();
}
// The same is true for the total supply and _mint and _burn.
function _transfer(address from, address to, uint256 value) internal {
_updateAccountSnapshot(from);
_updateAccountSnapshot(to);
super._transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
_updateAccountSnapshot(account);
_updateTotalSupplySnapshot();
super._mint(account, value);
}
function _burn(address account, uint256 value) internal {
_updateAccountSnapshot(account);
_updateTotalSupplySnapshot();
super._burn(account, value);
}
// When a valid snapshot is queried, there are three possibilities:
// to this id is the current one.
// requested id, and its value is the one to return.
// larger than the requested one.
//
// exactly this.
function _valueAt(uint256 snapshotId, Snapshots storage snapshots)
private view returns (bool, uint256)
{
require(snapshotId > 0, "ERC20Snapshot: id is 0");
// solhint-disable-next-line max-line-length
require(snapshotId <= _currentSnapshotId.current(), "ERC20Snapshot: nonexistent id");
uint256 index = snapshots.ids.findUpperBound(snapshotId);
if (index == snapshots.ids.length) {
return (false, 0);
} else {
return (true, snapshots.values[index]);
}
}
function _updateAccountSnapshot(address account) private {
_updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
}
function _updateTotalSupplySnapshot() private {
_updateSnapshot(_totalSupplySnapshots, totalSupply());
}
function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
uint256 currentId = _currentSnapshotId.current();
if (_lastSnapshotId(snapshots.ids) < currentId) {
snapshots.ids.push(currentId);
snapshots.values.push(currentValue);
}
}
function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) {
if (ids.length == 0) {
return 0;
} else {
return ids[ids.length - 1];
}
}
}
contract ExpandedIERC20 is IERC20 {
function burn(uint value) external;
function mint(address to, uint value) external returns (bool);
}
library Exclusive {
struct RoleMembership {
address member;
}
function isMember(RoleMembership storage roleMembership, address memberToCheck) internal view returns (bool) {
return roleMembership.member == memberToCheck;
}
function resetMember(RoleMembership storage roleMembership, address newMember) internal {
require(newMember != address(0x0), "Cannot set an exclusive role to 0x0");
roleMembership.member = newMember;
}
function getMember(RoleMembership storage roleMembership) internal view returns (address) {
return roleMembership.member;
}
function init(RoleMembership storage roleMembership, address initialMember) internal {
resetMember(roleMembership, initialMember);
}
}
library Shared {
struct RoleMembership {
mapping(address => bool) members;
}
function isMember(RoleMembership storage roleMembership, address memberToCheck) internal view returns (bool) {
return roleMembership.members[memberToCheck];
}
function addMember(RoleMembership storage roleMembership, address memberToAdd) internal {
roleMembership.members[memberToAdd] = true;
}
function removeMember(RoleMembership storage roleMembership, address memberToRemove) internal {
roleMembership.members[memberToRemove] = false;
}
function init(RoleMembership storage roleMembership, address[] memory initialMembers) internal {
for (uint i = 0; i < initialMembers.length; i++) {
addMember(roleMembership, initialMembers[i]);
}
}
}
contract MultiRole {
using Exclusive for Exclusive.RoleMembership;
using Shared for Shared.RoleMembership;
enum RoleType { Invalid, Exclusive, Shared }
struct Role {
uint managingRole;
RoleType roleType;
Exclusive.RoleMembership exclusiveRoleMembership;
Shared.RoleMembership sharedRoleMembership;
}
mapping(uint => Role) private roles;
modifier onlyRoleHolder(uint roleId) {
require(holdsRole(roleId, msg.sender), "Sender does not hold required role");
_;
}
modifier onlyRoleManager(uint roleId) {
require(holdsRole(roles[roleId].managingRole, msg.sender), "Can only be called by a role manager");
_;
}
modifier onlyExclusive(uint roleId) {
require(roles[roleId].roleType == RoleType.Exclusive, "Must be called on an initialized Exclusive role");
_;
}
modifier onlyShared(uint roleId) {
require(roles[roleId].roleType == RoleType.Shared, "Must be called on an initialized Shared role");
_;
}
function holdsRole(uint roleId, address memberToCheck) public view returns (bool) {
Role storage role = roles[roleId];
if (role.roleType == RoleType.Exclusive) {
return role.exclusiveRoleMembership.isMember(memberToCheck);
} else if (role.roleType == RoleType.Shared) {
return role.sharedRoleMembership.isMember(memberToCheck);
}
require(false, "Invalid roleId");
}
function resetMember(uint roleId, address newMember) public onlyExclusive(roleId) onlyRoleManager(roleId) {
roles[roleId].exclusiveRoleMembership.resetMember(newMember);
}
function getMember(uint roleId) public view onlyExclusive(roleId) returns (address) {
return roles[roleId].exclusiveRoleMembership.getMember();
}
function addMember(uint roleId, address newMember) public onlyShared(roleId) onlyRoleManager(roleId) {
roles[roleId].sharedRoleMembership.addMember(newMember);
}
function removeMember(uint roleId, address memberToRemove) public onlyShared(roleId) onlyRoleManager(roleId) {
roles[roleId].sharedRoleMembership.removeMember(memberToRemove);
}
modifier onlyValidRole(uint roleId) {
require(roles[roleId].roleType != RoleType.Invalid, "Attempted to use an invalid roleId");
_;
}
modifier onlyInvalidRole(uint roleId) {
require(roles[roleId].roleType == RoleType.Invalid, "Cannot use a pre-existing role");
_;
}
function _createSharedRole(uint roleId, uint managingRoleId, address[] memory initialMembers)
internal
onlyInvalidRole(roleId)
{
Role storage role = roles[roleId];
role.roleType = RoleType.Shared;
role.managingRole = managingRoleId;
role.sharedRoleMembership.init(initialMembers);
require(roles[managingRoleId].roleType != RoleType.Invalid,
"Attempted to use an invalid role to manage a shared role");
}
function _createExclusiveRole(uint roleId, uint managingRoleId, address initialMember)
internal
onlyInvalidRole(roleId)
{
Role storage role = roles[roleId];
role.roleType = RoleType.Exclusive;
role.managingRole = managingRoleId;
role.exclusiveRoleMembership.init(initialMember);
require(roles[managingRoleId].roleType != RoleType.Invalid,
"Attempted to use an invalid role to manage an exclusive role");
}
}
contract VotingToken is ExpandedIERC20, ERC20Snapshot, MultiRole {
enum Roles {
// Can set the minter and burner.
Owner,
// Addresses that can mint new tokens.
Minter,
// Addresses that can burn tokens that address owns.
Burner
}
// Standard ERC20 metadata.
string public constant name = "UMA Voting Token v1"; // solhint-disable-line const-name-snakecase
string public constant symbol = "UMA"; // solhint-disable-line const-name-snakecase
uint8 public constant decimals = 18; // solhint-disable-line const-name-snakecase
constructor() public {
_createExclusiveRole(uint(Roles.Owner), uint(Roles.Owner), msg.sender);
_createSharedRole(uint(Roles.Minter), uint(Roles.Owner), new address[](0));
_createSharedRole(uint(Roles.Burner), uint(Roles.Owner), new address[](0));
}
function mint(address recipient, uint value) external onlyRoleHolder(uint(Roles.Minter)) returns (bool) {
_mint(recipient, value);
return true;
}
function burn(uint value) external onlyRoleHolder(uint(Roles.Burner)) {
_burn(msg.sender, value);
}
}
| 264,351 | 10,741 |
5d09e1f6340244d2c4e00903878a64289233255f4254930dc669414fe933583e
| 20,109 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Utilities/0x819Bb9964B6eBF52361F1ae42CF4831B921510f9.sol
| 4,470 | 18,200 |
pragma solidity ^0.4.24;
// produced by the Solididy File Flattener (c) David Appleton 2018
// contact : dave@akomba.com
// released under Apache 2.0 licence
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract ERC20 {
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
}
contract V00_Marketplace is Ownable {
event MarketplaceData (address indexed party, bytes32 ipfsHash);
event AffiliateAdded (address indexed party, bytes32 ipfsHash);
event AffiliateRemoved (address indexed party, bytes32 ipfsHash);
event ListingCreated (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingUpdated (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingWithdrawn (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingArbitrated(address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingData (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event OfferCreated (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferAccepted (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferFinalized (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferWithdrawn (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferFundsAdded (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferDisputed (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferRuling (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash, uint ruling);
event OfferData (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
struct Listing {
address seller; // Seller wallet / identity contract / other contract
uint deposit; // Deposit in Origin Token
address depositManager; // Address that decides token distribution
}
struct Offer {
uint value; // Amount in Eth or ERC20 buyer is offering
uint commission; // Amount of commission earned if offer is finalized
uint refund; // Amount to refund buyer upon finalization
ERC20 currency; // Currency of listing
address buyer; // Buyer wallet / identity contract / other contract
address affiliate; // Address to send any commission
address arbitrator; // Address that settles disputes
uint finalizes; // Timestamp offer finalizes
uint8 status; // 0: Undefined, 1: Created, 2: Accepted, 3: Disputed
}
Listing[] public listings;
mapping(uint => Offer[]) public offers; // listingID => Offers
mapping(address => bool) public allowedAffiliates;
ERC20 public tokenAddr; // Origin Token address
constructor(address _tokenAddr) public {
owner = msg.sender;
setTokenAddr(_tokenAddr); // Origin Token contract
allowedAffiliates[0x0] = true; // Allow null affiliate by default
}
// @dev Return the total number of listings
function totalListings() public view returns (uint) {
return listings.length;
}
// @dev Return the total number of offers
function totalOffers(uint listingID) public view returns (uint) {
return offers[listingID].length;
}
// @dev Seller creates listing
function createListing(bytes32 _ipfsHash, uint _deposit, address _depositManager)
public
{
_createListing(msg.sender, _ipfsHash, _deposit, _depositManager);
}
// @dev Can only be called by token
function createListingWithSender(address _seller,
bytes32 _ipfsHash,
uint _deposit,
address _depositManager)
public returns (bool)
{
require(msg.sender == address(tokenAddr), "Token must call");
_createListing(_seller, _ipfsHash, _deposit, _depositManager);
return true;
}
// Private
function _createListing(address _seller,
bytes32 _ipfsHash, // IPFS JSON with details, pricing, availability
uint _deposit, // Deposit in Origin Token
address _depositManager // Address of listing depositManager)
private
{
require(_depositManager != 0x0, "Must specify depositManager");
listings.push(Listing({
seller: _seller,
deposit: _deposit,
depositManager: _depositManager
}));
if (_deposit > 0) {
tokenAddr.transferFrom(_seller, this, _deposit); // Transfer Origin Token
}
emit ListingCreated(_seller, listings.length - 1, _ipfsHash);
}
// @dev Seller updates listing
function updateListing(uint listingID,
bytes32 _ipfsHash,
uint _additionalDeposit) public {
_updateListing(msg.sender, listingID, _ipfsHash, _additionalDeposit);
}
function updateListingWithSender(address _seller,
uint listingID,
bytes32 _ipfsHash,
uint _additionalDeposit)
public returns (bool)
{
require(msg.sender == address(tokenAddr), "Token must call");
_updateListing(_seller, listingID, _ipfsHash, _additionalDeposit);
return true;
}
function _updateListing(address _seller,
uint listingID,
bytes32 _ipfsHash, // Updated IPFS hash
uint _additionalDeposit // Additional deposit to add) private {
Listing storage listing = listings[listingID];
require(listing.seller == _seller, "Seller must call");
if (_additionalDeposit > 0) {
tokenAddr.transferFrom(_seller, this, _additionalDeposit);
listing.deposit += _additionalDeposit;
}
emit ListingUpdated(listing.seller, listingID, _ipfsHash);
}
// @dev Listing depositManager withdraws listing. IPFS hash contains reason for withdrawl.
function withdrawListing(uint listingID, address _target, bytes32 _ipfsHash) public {
Listing storage listing = listings[listingID];
require(msg.sender == listing.depositManager, "Must be depositManager");
require(_target != 0x0, "No target");
tokenAddr.transfer(_target, listing.deposit); // Send deposit to target
emit ListingWithdrawn(_target, listingID, _ipfsHash);
}
// @dev Buyer makes offer.
function makeOffer(uint listingID,
bytes32 _ipfsHash, // IPFS hash containing offer data
uint _finalizes, // Timestamp an accepted offer will finalize
address _affiliate, // Address to send any required commission to
uint256 _commission, // Amount of commission to send in Origin Token if offer finalizes
uint _value, // Offer amount in ERC20 or Eth
ERC20 _currency, // ERC20 token address or 0x0 for Eth
address _arbitrator // Escrow arbitrator)
public
payable
{
bool affiliateWhitelistDisabled = allowedAffiliates[address(this)];
require(affiliateWhitelistDisabled || allowedAffiliates[_affiliate],
"Affiliate not allowed");
if (_affiliate == 0x0) {
// Avoid commission tokens being trapped in marketplace contract.
require(_commission == 0, "commission requires affiliate");
}
offers[listingID].push(Offer({
status: 1,
buyer: msg.sender,
finalizes: _finalizes,
affiliate: _affiliate,
commission: _commission,
currency: _currency,
value: _value,
arbitrator: _arbitrator,
refund: 0
}));
if (address(_currency) == 0x0) { // Listing is in ETH
require(msg.value == _value, "ETH value doesn't match offer");
} else { // Listing is in ERC20
require(msg.value == 0, "ETH would be lost");
require(_currency.transferFrom(msg.sender, this, _value),
"transferFrom failed");
}
emit OfferCreated(msg.sender, listingID, offers[listingID].length-1, _ipfsHash);
}
// @dev Make new offer after withdrawl
function makeOffer(uint listingID,
bytes32 _ipfsHash,
uint _finalizes,
address _affiliate,
uint256 _commission,
uint _value,
ERC20 _currency,
address _arbitrator,
uint _withdrawOfferID)
public
payable
{
withdrawOffer(listingID, _withdrawOfferID, _ipfsHash);
makeOffer(listingID, _ipfsHash, _finalizes, _affiliate, _commission, _value, _currency, _arbitrator);
}
// @dev Seller accepts offer
function acceptOffer(uint listingID, uint offerID, bytes32 _ipfsHash) public {
Listing storage listing = listings[listingID];
Offer storage offer = offers[listingID][offerID];
require(msg.sender == listing.seller, "Seller must accept");
require(offer.status == 1, "status != created");
require(listing.deposit >= offer.commission,
"deposit must cover commission");
if (offer.finalizes < 1000000000) { // Relative finalization window
offer.finalizes = now + offer.finalizes;
}
listing.deposit -= offer.commission; // Accepting an offer puts Origin Token into escrow
offer.status = 2; // Set offer to 'Accepted'
emit OfferAccepted(msg.sender, listingID, offerID, _ipfsHash);
}
// @dev Buyer withdraws offer. IPFS hash contains reason for withdrawl.
function withdrawOffer(uint listingID, uint offerID, bytes32 _ipfsHash) public {
Listing storage listing = listings[listingID];
Offer storage offer = offers[listingID][offerID];
require(msg.sender == offer.buyer || msg.sender == listing.seller,
"Restricted to buyer or seller");
require(offer.status == 1, "status != created");
refundBuyer(listingID, offerID);
emit OfferWithdrawn(msg.sender, listingID, offerID, _ipfsHash);
delete offers[listingID][offerID];
}
// @dev Buyer adds extra funds to an accepted offer.
function addFunds(uint listingID, uint offerID, bytes32 _ipfsHash, uint _value) public payable {
Offer storage offer = offers[listingID][offerID];
require(msg.sender == offer.buyer, "Buyer must call");
require(offer.status == 2, "status != accepted");
if (address(offer.currency) == 0x0) { // Listing is in ETH
require(msg.value == _value,
"sent != offered value");
} else { // Listing is in ERC20
require(msg.value == 0, "ETH must not be sent");
require(offer.currency.transferFrom(msg.sender, this, _value),
"transferFrom failed");
}
offer.value += _value;
emit OfferFundsAdded(msg.sender, listingID, offerID, _ipfsHash);
}
// @dev Buyer must finalize transaction to receive commission
function finalize(uint listingID, uint offerID, bytes32 _ipfsHash) public {
Listing storage listing = listings[listingID];
Offer storage offer = offers[listingID][offerID];
if (now <= offer.finalizes) { // Only buyer can finalize before finalization window
require(msg.sender == offer.buyer,
"Only buyer can finalize");
} else { // Allow both seller and buyer to finalize if finalization window has passed
require(msg.sender == offer.buyer || msg.sender == listing.seller,
"Seller or buyer must finalize");
}
require(offer.status == 2, "status != accepted");
paySeller(listingID, offerID); // Pay seller
if (msg.sender == offer.buyer) { // Only pay commission if buyer is finalizing
payCommission(listingID, offerID);
}
emit OfferFinalized(msg.sender, listingID, offerID, _ipfsHash);
delete offers[listingID][offerID];
}
// @dev Buyer or seller can dispute transaction during finalization window
function dispute(uint listingID, uint offerID, bytes32 _ipfsHash) public {
Listing storage listing = listings[listingID];
Offer storage offer = offers[listingID][offerID];
require(msg.sender == offer.buyer || msg.sender == listing.seller,
"Must be seller or buyer");
require(offer.status == 2, "status != accepted");
require(now <= offer.finalizes, "Already finalized");
offer.status = 3; // Set status to "Disputed"
emit OfferDisputed(msg.sender, listingID, offerID, _ipfsHash);
}
// @dev Called by arbitrator
function executeRuling(uint listingID,
uint offerID,
bytes32 _ipfsHash,
uint _ruling, // 0: Seller, 1: Buyer, 2: Com + Seller, 3: Com + Buyer
uint _refund) public {
Offer storage offer = offers[listingID][offerID];
require(msg.sender == offer.arbitrator, "Must be arbitrator");
require(offer.status == 3, "status != disputed");
require(_refund <= offer.value, "refund too high");
offer.refund = _refund;
if (_ruling & 1 == 1) {
refundBuyer(listingID, offerID);
} else {
paySeller(listingID, offerID);
}
if (_ruling & 2 == 2) {
payCommission(listingID, offerID);
} else { // Refund commission to seller
listings[listingID].deposit += offer.commission;
}
emit OfferRuling(offer.arbitrator, listingID, offerID, _ipfsHash, _ruling);
delete offers[listingID][offerID];
}
// @dev Sets the amount that a seller wants to refund to a buyer.
function updateRefund(uint listingID, uint offerID, uint _refund, bytes32 _ipfsHash) public {
Offer storage offer = offers[listingID][offerID];
Listing storage listing = listings[listingID];
require(msg.sender == listing.seller, "Seller must call");
require(offer.status == 2, "status != accepted");
require(_refund <= offer.value, "Excessive refund");
offer.refund = _refund;
emit OfferData(msg.sender, listingID, offerID, _ipfsHash);
}
function refundBuyer(uint listingID, uint offerID) private {
Offer storage offer = offers[listingID][offerID];
if (address(offer.currency) == 0x0) {
require(offer.buyer.send(offer.value), "ETH refund failed");
} else {
require(offer.currency.transfer(offer.buyer, offer.value),
"Refund failed");
}
}
// @dev Pay seller in ETH or ERC20
function paySeller(uint listingID, uint offerID) private {
Listing storage listing = listings[listingID];
Offer storage offer = offers[listingID][offerID];
uint value = offer.value - offer.refund;
if (address(offer.currency) == 0x0) {
require(offer.buyer.send(offer.refund), "ETH refund failed");
require(listing.seller.send(value), "ETH send failed");
} else {
require(offer.currency.transfer(offer.buyer, offer.refund),
"Refund failed");
require(offer.currency.transfer(listing.seller, value),
"Transfer failed");
}
}
// @dev Pay commission to affiliate
function payCommission(uint listingID, uint offerID) private {
Offer storage offer = offers[listingID][offerID];
if (offer.affiliate != 0x0) {
require(tokenAddr.transfer(offer.affiliate, offer.commission),
"Commission transfer failed");
}
}
// @dev Associate ipfs data with the marketplace
function addData(bytes32 ipfsHash) public {
emit MarketplaceData(msg.sender, ipfsHash);
}
// @dev Associate ipfs data with a listing
function addData(uint listingID, bytes32 ipfsHash) public {
emit ListingData(msg.sender, listingID, ipfsHash);
}
// @dev Associate ipfs data with an offer
function addData(uint listingID, uint offerID, bytes32 ipfsHash) public {
emit OfferData(msg.sender, listingID, offerID, ipfsHash);
}
// @dev Allow listing depositManager to send deposit
function sendDeposit(uint listingID, address target, uint value, bytes32 ipfsHash) public {
Listing storage listing = listings[listingID];
require(listing.depositManager == msg.sender, "depositManager must call");
require(listing.deposit >= value, "Value too high");
listing.deposit -= value;
require(tokenAddr.transfer(target, value), "Transfer failed");
emit ListingArbitrated(target, listingID, ipfsHash);
}
// @dev Set the address of the Origin token contract
function setTokenAddr(address _tokenAddr) public onlyOwner {
tokenAddr = ERC20(_tokenAddr);
}
// @dev Add affiliate to whitelist. Set to address(this) to disable.
function addAffiliate(address _affiliate, bytes32 ipfsHash) public onlyOwner {
allowedAffiliates[_affiliate] = true;
emit AffiliateAdded(_affiliate, ipfsHash);
}
// @dev Remove affiliate from whitelist.
function removeAffiliate(address _affiliate, bytes32 ipfsHash) public onlyOwner {
delete allowedAffiliates[_affiliate];
emit AffiliateRemoved(_affiliate, ipfsHash);
}
}
| 336,400 | 10,742 |
c98011be3f7bb2c26bfd6c71a9d89365a916737cbd23d40c5d164fc00409985c
| 32,484 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0xcc2f10a0a3886657f925a6ee7fd7664497f3d123_affectedByMiners.sol
| 3,493 | 13,436 |
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 (block.gaslimit > 0) { //injected CONTRACT AFFECTED BY MINERS
// 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 (block.gaslimit > 0) {// Return data is optional //injected CONTRACT AFFECTED BY MINERS
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
// beijingtoken with Governance.
contract beijingtoken is ERC20("BEIJING.CITY.finance", "BEIJING"), Ownable {
uint256 public constant MAX_SUPPLY = 17550000 * 10**18;
function mint(address _to, uint256 _amount) public onlyOwner {
uint256 _totalSupply = totalSupply();
if(block.timestamp > MAX_SUPPLY) { //injected CONTRACT AFFECTED BY MINERS
_amount = MAX_SUPPLY.sub(_totalSupply);
}
require(_totalSupply.add(_amount) <= MAX_SUPPLY);
_mint(_to, _amount);
}
}
| 281,099 | 10,743 |
1c931fd7a5f4cb35a937b3b1253863473aceb64d0ba41d23df1f73d04241f1c8
| 12,084 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xe05cedd2838e4e1d99b539d8c768d6ef2a10f729.sol
| 3,513 | 11,396 |
pragma solidity ^0.4.8;
contract SafeMath {
function assert(bool assertion) internal {
if (!assertion) throw;
}
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
}
contract StandardTokenProtocol {
function totalSupply() constant returns (uint256 totalSupply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _recipient, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _recipient, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _recipient, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is StandardTokenProtocol {
modifier when_can_transfer(address _from, uint256 _value) {
if (balances[_from] >= _value) _;
}
modifier when_can_receive(address _recipient, uint256 _value) {
if (balances[_recipient] + _value > balances[_recipient]) _;
}
modifier when_is_allowed(address _from, address _delegate, uint256 _value) {
if (allowed[_from][_delegate] >= _value) _;
}
function transfer(address _recipient, uint256 _value)
when_can_transfer(msg.sender, _value)
when_can_receive(_recipient, _value)
returns (bool o_success)
{
balances[msg.sender] -= _value;
balances[_recipient] += _value;
Transfer(msg.sender, _recipient, _value);
return true;
}
function transferFrom(address _from, address _recipient, uint256 _value)
when_can_transfer(_from, _value)
when_can_receive(_recipient, _value)
when_is_allowed(_from, msg.sender, _value)
returns (bool o_success)
{
allowed[_from][msg.sender] -= _value;
balances[_from] -= _value;
balances[_recipient] += _value;
Transfer(_from, _recipient, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool o_success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 o_remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract GUPToken is StandardToken {
//FIELDS
string public name = "Guppy";
string public symbol = "GUP";
uint public decimals = 3;
//CONSTANTS
uint public constant LOCKOUT_PERIOD = 1 years; //time after end date that illiquid GUP can be transferred
//ASSIGNED IN INITIALIZATION
uint public endMintingTime; //Timestamp after which no more tokens can be created
address public minter; //address of the account which may mint new tokens
mapping (address => uint) public illiquidBalance; //Balance of 'Frozen funds'
//MODIFIERS
//Can only be called by contribution contract.
modifier only_minter {
if (msg.sender != minter) throw;
_;
}
// Can only be called if illiquid tokens may be transformed into liquid.
// This happens when `LOCKOUT_PERIOD` of time passes after `endMintingTime`.
modifier when_thawable {
if (now < endMintingTime + LOCKOUT_PERIOD) throw;
_;
}
// Can only be called if (liquid) tokens may be transferred. Happens
// immediately after `endMintingTime`.
modifier when_transferable {
if (now < endMintingTime) throw;
_;
}
// Can only be called if the `crowdfunder` is allowed to mint tokens. Any
// time before `endMintingTime`.
modifier when_mintable {
if (now >= endMintingTime) throw;
_;
}
// Initialization contract assigns address of crowdfund contract and end time.
function GUPToken(address _minter, uint _endMintingTime) {
endMintingTime = _endMintingTime;
minter = _minter;
}
// Create new tokens when called by the crowdfund contract.
// Only callable before the end time.
function createToken(address _recipient, uint _value)
when_mintable
only_minter
returns (bool o_success)
{
balances[_recipient] += _value;
totalSupply += _value;
return true;
}
// Create an illiquidBalance which cannot be traded until end of lockout period.
// Can only be called by crowdfund contract before the end time.
function createIlliquidToken(address _recipient, uint _value)
when_mintable
only_minter
returns (bool o_success)
{
illiquidBalance[_recipient] += _value;
totalSupply += _value;
return true;
}
// Make sender's illiquid balance liquid when called after lockout period.
function makeLiquid()
when_thawable
{
balances[msg.sender] += illiquidBalance[msg.sender];
illiquidBalance[msg.sender] = 0;
}
// Transfer amount of tokens from sender account to recipient.
// Only callable after the crowd fund end date.
function transfer(address _recipient, uint _amount)
when_transferable
returns (bool o_success)
{
return super.transfer(_recipient, _amount);
}
// Transfer amount of tokens from a specified address to a recipient.
// Only callable after the crowd fund end date.
function transferFrom(address _from, address _recipient, uint _amount)
when_transferable
returns (bool o_success)
{
return super.transferFrom(_from, _recipient, _amount);
}
}
contract Contribution is SafeMath {
//FIELDS
//CONSTANTS
//Time limits
uint public constant STAGE_ONE_TIME_END = 5 hours;
uint public constant STAGE_TWO_TIME_END = 72 hours;
uint public constant STAGE_THREE_TIME_END = 2 weeks;
uint public constant STAGE_FOUR_TIME_END = 4 weeks;
//Prices of GUP
uint public constant PRICE_STAGE_ONE = 480000;
uint public constant PRICE_STAGE_TWO = 440000;
uint public constant PRICE_STAGE_THREE = 400000;
uint public constant PRICE_STAGE_FOUR = 360000;
uint public constant PRICE_BTCS = 480000;
//GUP Token Limits
uint public constant MAX_SUPPLY = 100000000000;
uint public constant ALLOC_ILLIQUID_TEAM = 8000000000;
uint public constant ALLOC_LIQUID_TEAM = 13000000000;
uint public constant ALLOC_BOUNTIES = 2000000000;
uint public constant ALLOC_NEW_USERS = 17000000000;
uint public constant ALLOC_CROWDSALE = 60000000000;
uint public constant BTCS_PORTION_MAX = 31250 * PRICE_BTCS;
//ASSIGNED IN INITIALIZATION
//Start and end times
uint public publicStartTime; //Time in seconds public crowd fund starts.
uint public privateStartTime; //Time in seconds when BTCSuisse can purchase up to 31250 ETH worth of GUP;
uint public publicEndTime; //Time in seconds crowdsale ends
//Special Addresses
address public btcsAddress; //Address used by BTCSuisse
address public multisigAddress; //Address to which all ether flows.
address public matchpoolAddress;
address public ownerAddress; //Address of the contract owner. Can halt the crowdsale.
//Contracts
GUPToken public gupToken; //External token contract hollding the GUP
//Running totals
uint public etherRaised; //Total Ether raised.
uint public gupSold; //Total GUP created
uint public btcsPortionTotal; //Total of Tokens purchased by BTC Suisse. Not to exceed BTCS_PORTION_MAX.
//booleans
bool public halted; //halts the crowd sale if true.
//FUNCTION MODIFIERS
//Is currently in the period after the private start time and before the public start time.
modifier is_pre_crowdfund_period() {
if (now >= publicStartTime || now < privateStartTime) throw;
_;
}
//Is currently the crowdfund period
modifier is_crowdfund_period() {
if (now < publicStartTime || now >= publicEndTime) throw;
_;
}
//May only be called by BTC Suisse
modifier only_btcs() {
if (msg.sender != btcsAddress) throw;
_;
}
//May only be called by the owner address
modifier only_owner() {
if (msg.sender != ownerAddress) throw;
_;
}
//May only be called if the crowdfund has not been halted
modifier is_not_halted() {
if (halted) throw;
_;
}
// EVENTS
event PreBuy(uint _amount);
event Buy(address indexed _recipient, uint _amount);
// FUNCTIONS
function Contribution(address _btcs,
address _multisig,
address _matchpool,
uint _publicStartTime,
uint _privateStartTime) {
ownerAddress = msg.sender;
publicStartTime = _publicStartTime;
privateStartTime = _privateStartTime;
publicEndTime = _publicStartTime + 4 weeks;
btcsAddress = _btcs;
multisigAddress = _multisig;
matchpoolAddress = _matchpool;
gupToken = new GUPToken(this, publicEndTime);
gupToken.createIlliquidToken(matchpoolAddress, ALLOC_ILLIQUID_TEAM);
gupToken.createToken(matchpoolAddress, ALLOC_BOUNTIES);
gupToken.createToken(matchpoolAddress, ALLOC_LIQUID_TEAM);
gupToken.createToken(matchpoolAddress, ALLOC_NEW_USERS);
}
//May be used by owner of contract to halt crowdsale and no longer except ether.
function toggleHalt(bool _halted)
only_owner
{
halted = _halted;
}
//constant function returns the current GUP price.
function getPriceRate()
constant
returns (uint o_rate)
{
if (now <= publicStartTime + STAGE_ONE_TIME_END) return PRICE_STAGE_ONE;
if (now <= publicStartTime + STAGE_TWO_TIME_END) return PRICE_STAGE_TWO;
if (now <= publicStartTime + STAGE_THREE_TIME_END) return PRICE_STAGE_THREE;
if (now <= publicStartTime + STAGE_FOUR_TIME_END) return PRICE_STAGE_FOUR;
else return 0;
}
// Given the rate of a purchase and the remaining tokens in this tranche, it
// will throw if the sale would take it past the limit of the tranche.
// It executes the purchase for the appropriate amount of tokens, which
// involves adding it to the total, minting GUP tokens and stashing the
// ether.
// Returns `amount` in scope as the number of GUP tokens that it will
// purchase.
function processPurchase(uint _rate, uint _remaining)
internal
returns (uint o_amount)
{
o_amount = safeDiv(safeMul(msg.value, _rate), 1 ether);
if (o_amount > _remaining) throw;
if (!multisigAddress.send(msg.value)) throw;
if (!gupToken.createToken(msg.sender, o_amount)) throw;
gupSold += o_amount;
etherRaised += msg.value;
}
//Special Function can only be called by BTC Suisse and only during the pre-crowdsale period.
//Allows the purchase of up to 125000 Ether worth of GUP Tokens.
function preBuy()
payable
is_pre_crowdfund_period
only_btcs
is_not_halted
{
uint amount = processPurchase(PRICE_BTCS, BTCS_PORTION_MAX - btcsPortionTotal);
btcsPortionTotal += amount;
PreBuy(amount);
}
//Default function called by sending Ether to this address with no arguments.
//Results in creation of new GUP Tokens if transaction would not exceed hard limit of GUP Token.
function()
payable
is_crowdfund_period
is_not_halted
{
uint amount = processPurchase(getPriceRate(), ALLOC_CROWDSALE - gupSold);
Buy(msg.sender, amount);
}
//failsafe drain
function drain()
only_owner
{
if (!ownerAddress.send(this.balance)) throw;
}
}
| 142,465 | 10,744 |
1cf08eccd1667cd87807e8e9c57565ee27cefe605e0fddf053a5f40c25df7531
| 10,972 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x8e59651c365af64ca47d1e6df072828da262fcb8.sol
| 2,722 | 10,290 |
pragma solidity 0.4.24;
contract Math {
function add(uint256 x, uint256 y) pure internal returns(uint256) {
uint256 z = x + y;
assert((z >= x) && (z >= y));
return z;
}
function subtract(uint256 x, uint256 y) pure internal returns(uint256) {
assert(x >= y);
uint256 z = x - y;
return z;
}
}
contract Auth {
address owner = 0x0;
address admin = 0x0;
modifier isOwner {
require(owner == msg.sender);
_;
}
modifier isAdmin {
require(owner == msg.sender || admin == msg.sender);
_;
}
function setOwner(address _owner) isOwner public {
owner = _owner;
}
function setAdmin(address _admin) isOwner public {
admin = _admin;
}
function getManagers() public view returns (address _owner, address _admin) {
return (owner, admin);
}
}
contract Manage is Auth {
uint8 public status = 0;
modifier isRunning {
require(status == 2 || owner == msg.sender || admin == msg.sender || (status == 1 && (owner == msg.sender || admin == msg.sender)));
_;
}
function limit() isAdmin public {
require(status != 1);
status = 1;
}
function start() isAdmin public {
require(status != 2);
status = 2;
}
function close() isAdmin public {
require(status != 3);
status = 3;
}
}
contract EIP20Interface {
uint256 public totalSupply;
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract TokenBase is EIP20Interface, Manage, Math {
string public name;
string public symbol;
uint8 public decimals;
event Burn(address indexed from, uint256 value);
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
constructor() public {
owner = msg.sender;
admin = msg.sender;
}
function init(uint256 initialSupply, string tokenName, string tokenSymbol, uint8 tokenDecimals) internal {
require(status == 0);
totalSupply = initialSupply * 10 ** uint256(tokenDecimals);
balances[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = tokenDecimals;
status = 1;
}
function _transfer(address _from, address _to, uint256 _value) isRunning internal {
require(0x0 != _to);
require(balances[_from] >= _value);
require(balances[_to] + _value >= balances[_to]);
uint previousBalances = balances[_from] + balances[_to];
balances[_from] = Math.subtract(balances[_from], _value);
balances[_to] = Math.add(balances[_to], _value);
emit Transfer(_from, _to, _value);
assert(balances[_from] + balances[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowed[_from][msg.sender]);
allowed[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) isRunning public returns (bool success) {
require(_value == 0 || allowed[msg.sender][_spender] == 0);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function increaseApproval(address _spender, uint256 _value) isRunning public returns (bool success) {
allowed[msg.sender][_spender] = Math.add(allowed[msg.sender][_spender], _value);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _value) isRunning public returns (bool success) {
uint256 oldValue = allowed[msg.sender][_spender];
if (_value >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = Math.subtract(oldValue, _value);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function burn(uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value); // Check if the sender has enough
balances[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(balances[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowed[_from][msg.sender]); // Check allowance
balances[_from] -= _value; // Subtract from the targeted balance
allowed[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function destruct() isOwner public {
selfdestruct(owner);
}
}
contract AutoBit is TokenBase {
uint256 public sellPrice;
uint256 public buyPrice;
uint8 freezePercent;
address[] private frozenAddresses;
mapping (address => uint256) public frozenBalances;
mapping (address => mapping (uint256 => uint256)) public payedBalances;
event FrozenBalance(address indexed target, uint256 balance);
event Price(uint256 newSellPrice, uint256 newBuyPrice);
constructor() TokenBase() public {
init(10000000000, "AutoBit", "ATB", 18);
freezePercent = 100;
emit Transfer(address(0), msg.sender, totalSupply);
}
function _transfer(address _from, address _to, uint256 _value) isRunning internal {
require(frozenBalances[_from] <= balances[_from] - _value);
super._transfer(_from, _to, _value);
if(status == 1)
freeze(_to, freezePercent);
}
function increaseFrozenBalances(address target, uint256 _value) isAdmin public {
require(_value > 0);
if(frozenBalances[target] == 0)
frozenAddresses.push(target);
frozenBalances[target] += _value;
emit FrozenBalance(target, frozenBalances[target]);
}
function decreaseFrozenBalances(address target, uint256 _value) isAdmin public {
require(_value > 0 && frozenBalances[target] >= _value);
frozenBalances[target] -= _value;
if(frozenBalances[target] == 0)
deleteFrozenAddresses(target);
emit FrozenBalance(target, frozenBalances[target]);
}
function freeze(address target, uint8 percent) isAdmin public {
require(percent > 0 && percent <= 100);
if(frozenBalances[target] == 0)
frozenAddresses.push(target);
uint256 frozenBalance = balances[target] * percent / 100;
frozenBalances[target] = frozenBalance;
emit FrozenBalance(target, frozenBalance);
}
function changeFrozenBalanceAll(uint8 percent) isAdmin public {
uint arrayLength = frozenAddresses.length;
for (uint i=0; i<arrayLength; i++) {
uint256 frozenBalance = balances[frozenAddresses[i]] * percent / 100;
frozenBalances[frozenAddresses[i]] = frozenBalance;
}
}
function unfreeze(address target) isAdmin public {
deleteFrozenAddresses(target);
delete frozenBalances[target];
}
function deleteFrozenAddresses(address target) private {
uint arrayLength = frozenAddresses.length;
uint indexToBeDeleted;
for (uint i=0; i<arrayLength; i++) {
if (frozenAddresses[i] == target) {
indexToBeDeleted = i;
break;
}
}
address lastAddress = frozenAddresses[frozenAddresses.length-1];
frozenAddresses[indexToBeDeleted] = lastAddress;
frozenAddresses.length--;
}
function unfreezeAll() isAdmin public {
uint arrayLength = frozenAddresses.length;
for (uint i=0; i<arrayLength; i++) {
delete frozenBalances[frozenAddresses[i]];
}
delete frozenAddresses;
frozenAddresses.length = 0;
}
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) isAdmin public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
emit Price(sellPrice, buyPrice);
}
function pay(address _to, uint256 _value, uint256 no) public returns (bool success) {
_transfer(msg.sender, _to, _value);
payedBalances[msg.sender][no] = _value;
return true;
}
function payedBalancesOf(address target, uint256 no) public view returns (uint256 balance) {
return payedBalances[target][no];
}
function buy() payable public {
require(buyPrice > 0);
uint amount = msg.value / buyPrice;
_transfer(this, msg.sender, amount);
}
function sell(uint256 amount) public {
require(sellPrice > 0);
address myAddress = this;
require(myAddress.balance >= amount * sellPrice);
_transfer(msg.sender, this, amount);
msg.sender.transfer(amount * sellPrice);
}
function setFreezePercent(uint8 percent) isAdmin public {
freezePercent = percent;
}
function frozenBalancesOf(address target) public view returns (uint256 balance) {
return frozenBalances[target];
}
}
| 142,457 | 10,745 |
cf110017db28f794b5c8de954838d073d8569e2e1acb75b9e2891eb11b92bc37
| 13,340 |
.sol
|
Solidity
| false |
549281330
|
AtosDev/Token-Swap-Staking-Farming
|
41dc8d345ebfa51058435a3fa95201519ba7c3d5
|
Staking.sol
| 2,844 | 12,174 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(address to, uint256 value) external ;
function burn(address to, uint256 value) external ;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 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;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
interface IPancakeSwapPair {
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 IPancakeSwapRouter{
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);
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IPancakeSwapFactory {
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;
}
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);
}
}
contract StakingContract is Ownable {
struct Staker {
uint256 amount;
uint256 lastClaimed;
uint256 depositDate;
bool clamined;
bool tokenType;
}
address public nvt = 0xc021fb22B970F60Eff8340F08A5671eF68cCbc6d;
address public usct = 0xc6285b185A7069eC0f901912E5E2b79A6C0DCc19;
mapping(address => Staker) public user;
constructor() {
}
function deposit (address from, uint256 amount, bool tokenType) public {
require(!user[msg.sender].clamined, "You can deposit after withdraw");
require(from != address(0), "zero address");
Staker storage value = user[from];
value.amount = amount ;
value.clamined = false;
value.lastClaimed = block.timestamp;
value.depositDate = block.timestamp;
value.tokenType = tokenType;
if(tokenType)
{
IERC20(usct).transferFrom(msg.sender, address(this), amount);
} else {
IERC20(nvt).transferFrom(msg.sender, address(this), amount);
}
}
function withDrawRequest() public {
user[msg.sender].lastClaimed = block.timestamp;
user[msg.sender].clamined = true;
}
function withDraw() public {
require(user[msg.sender].clamined, "didnt request for withdraw");
require(block.timestamp - user[msg.sender].lastClaimed >= 12 * 60 * 60, "no withdraw time");
uint256 _reward = user[msg.sender].amount + (user[msg.sender].amount * 20 / 365) * (user[msg.sender].lastClaimed - user[msg.sender].depositDate) / (60 * 60 * 24);
if(user[msg.sender].tokenType){
IERC20(usct).transfer(msg.sender, user[msg.sender].amount + _reward);
} else {
IERC20(usct).transfer(msg.sender, _reward);
IERC20(nvt).transfer(msg.sender, user[msg.sender].amount);
}
}
}
| 282,011 | 10,746 |
e9b458bab4d48af3f7ae553f18c98a1e172fa674a1609ef126652cb433d703d0
| 23,737 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TC/TCTVAmXSpc23tNWpVaoTj9jUah4dvZyNvG_CryptoBank.sol
| 6,600 | 22,598 |
//SourceUnit: CryptoBank.sol
pragma solidity ^0.5.4;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
uint256 level4RefCount;
uint256 level5RefCount;
uint256 timer;
uint256 turnover;
uint256 currentLevel;
uint256 bonusEarnings;
}
struct Bonus {
uint256 gap;
uint256 prize;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract CryptoBank is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 20; //per thousand
uint256 public constant MARKETING_RATE = 30;
uint256 public constant ADMIN_RATE = 90;
uint256 public constant REFERENCE_RATE = 115;
uint256 public constant REFERENCE_LEVEL1_RATE = 50;
uint256 public constant REFERENCE_LEVEL2_RATE = 30;
uint256 public constant REFERENCE_LEVEL3_RATE = 20;
uint256 public constant REFERENCE_LEVEL4_RATE = 10;
uint256 public constant REFERENCE_LEVEL5_RATE = 5;
uint256 public constant ACTIVATION_TIME = 1606845600;
uint256 public constant MINIMUM = 50000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 6666; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
address payable private adminAccount_;
address payable private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
mapping(uint256 => Objects.Bonus) public bonusLevels;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = address(0x412aaed45184516ba71d7965bb1224d04b5c725699);
adminAccount_ = address(0x414e62818f6955bd299f023d41c0f88134e84197ba);
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function checkIn() public {
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(180, 8*60*60*24)); //45 days
investmentPlans_.push(Objects.Plan(160, 10*60*60*24)); //45 days
investmentPlans_.push(Objects.Plan(140, 13*60*60*24)); //25 days
investmentPlans_.push(Objects.Plan(120, 17*60*60*24)); //18 days
bonusLevels[1] = Objects.Bonus(15000*1e6,200*1e6);
bonusLevels[2] = Objects.Bonus(50000*1e6,300*1e6);
bonusLevels[3] = Objects.Bonus(100000*1e6,500*1e6);
bonusLevels[4] = Objects.Bonus(500000*1e6,4000*1e6);
bonusLevels[5] = Objects.Bonus(1000000*1e6,15000*1e6);
bonusLevels[6] = Objects.Bonus(5000000*1e6,80000*1e6);
bonusLevels[7] = Objects.Bonus(10000000*1e6,200000*1e6);
bonusLevels[8] = Objects.Bonus(20000000*1e6,1300000*1e6);
bonusLevels[9] = Objects.Bonus(50000000*1e6,2400000*1e6);
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
terms);
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getTimer(address _addr) public view returns (uint256) {
return uid2Investor[address2UID[_addr]].timer;
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256,uint256,uint256, uint256, uint256[] memory, uint256[] memory,uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory refStats = new uint256[](2);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
refStats[0] = investor.turnover;
refStats[1] = investor.bonusEarnings;
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.level4RefCount,
investor.level5RefCount,
investor.planCount,
currentDividends,
newDividends,
refStats);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
isExpireds[i] = true;
}
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _ref5 = uid2Investor[_ref4].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
if (_ref4 >= REFERRER_CODE) {
uid2Investor[_ref4].level4RefCount = uid2Investor[_ref4].level4RefCount.add(1);
}
if (_ref5 >= REFERRER_CODE) {
uid2Investor[_ref5].level5RefCount = uid2Investor[_ref5].level5RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(ACTIVATION_TIME < now , "NOT_YET_LAUNCHED");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
uint256 adminPercentage = (_amount.mul(ADMIN_RATE)).div(1000);
adminAccount_.transfer(adminPercentage);
return true;
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
require(uid2Investor[uid].timer < now, "withdrawal is available only once every 24 hours");
uid2Investor[uid].timer = now + 24 hours;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
msg.sender.transfer(withdrawalAmount);
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _ref5 = uid2Investor[_ref4].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
uid2Investor[_ref1].turnover = _investment.add(uid2Investor[_ref1].turnover);
if(uid2Investor[_ref1].currentLevel < 9 && bonusLevels[uid2Investor[_ref1].currentLevel + 1].gap <= uid2Investor[_ref1].turnover){
uid2Investor[_ref1].availableReferrerEarnings = bonusLevels[uid2Investor[_ref1].currentLevel + 1].prize.add(uid2Investor[_ref1].availableReferrerEarnings);
uid2Investor[_ref1].currentLevel++;
uid2Investor[_ref1].bonusEarnings = bonusLevels[uid2Investor[_ref1].currentLevel].prize.add(uid2Investor[_ref1].bonusEarnings);
}
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
uid2Investor[_ref2].turnover = (_investment.div(2)).add(uid2Investor[_ref2].turnover);
if(uid2Investor[_ref2].currentLevel < 9 && bonusLevels[uid2Investor[_ref2].currentLevel + 1].gap <= uid2Investor[_ref2].turnover){
uid2Investor[_ref2].availableReferrerEarnings = bonusLevels[uid2Investor[_ref2].currentLevel + 1].prize.add(uid2Investor[_ref2].availableReferrerEarnings);
uid2Investor[_ref2].currentLevel++;
uid2Investor[_ref2].bonusEarnings = bonusLevels[uid2Investor[_ref2].currentLevel].prize.add(uid2Investor[_ref2].bonusEarnings);
}
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
uid2Investor[_ref3].turnover = (_investment.div(4)).add(uid2Investor[_ref3].turnover);
if(uid2Investor[_ref3].currentLevel < 9 && bonusLevels[uid2Investor[_ref3].currentLevel + 1].gap <= uid2Investor[_ref3].turnover){
uid2Investor[_ref3].availableReferrerEarnings = bonusLevels[uid2Investor[_ref3].currentLevel + 1].prize.add(uid2Investor[_ref3].availableReferrerEarnings);
uid2Investor[_ref3].currentLevel++;
uid2Investor[_ref3].bonusEarnings = bonusLevels[uid2Investor[_ref3].currentLevel].prize.add(uid2Investor[_ref3].bonusEarnings);
}
}
if (_ref4 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL4_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref4].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref4].availableReferrerEarnings);
uid2Investor[_ref4].turnover = (_investment.div(10)).add(uid2Investor[_ref4].turnover);
if(uid2Investor[_ref4].currentLevel < 9 && bonusLevels[uid2Investor[_ref4].currentLevel + 1].gap <= uid2Investor[_ref4].turnover){
uid2Investor[_ref4].availableReferrerEarnings = bonusLevels[uid2Investor[_ref4].currentLevel + 1].prize.add(uid2Investor[_ref4].availableReferrerEarnings);
uid2Investor[_ref4].currentLevel++;
uid2Investor[_ref4].bonusEarnings = bonusLevels[uid2Investor[_ref4].currentLevel].prize.add(uid2Investor[_ref4].bonusEarnings);
}
}
if (_ref5 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL5_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref5].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref5].availableReferrerEarnings);
uid2Investor[_ref5].turnover = (_investment.div(20)).add(uid2Investor[_ref5].turnover);
if(uid2Investor[_ref5].currentLevel < 9 && bonusLevels[uid2Investor[_ref5].currentLevel + 1].gap <= uid2Investor[_ref5].turnover){
uid2Investor[_ref5].availableReferrerEarnings = bonusLevels[uid2Investor[_ref5].currentLevel + 1].prize.add(uid2Investor[_ref5].availableReferrerEarnings);
uid2Investor[_ref5].currentLevel++;
uid2Investor[_ref5].bonusEarnings = bonusLevels[uid2Investor[_ref5].currentLevel].prize.add(uid2Investor[_ref5].bonusEarnings);
}
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 303,948 | 10,747 |
e120e7c4a27b650f6ae8c8e0a1d6ae5462acdc12aceb40ac49bde06c1502c9d9
| 32,260 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/23/231d1b974b2f309d48c46b7a482b148d3ee97396_AddressUpgradeable.sol
| 5,587 | 19,889 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
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 verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
// If the contract is initializing we ignore whether _initialized is set in order to support multiple
// contract may have been reentered.
require(_initializing ? _isConstructor() : !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _isConstructor() private view returns (bool) {
return !AddressUpgradeable.isContract(address(this));
}
}
abstract contract ReentrancyGuardUpgradeable is Initializable {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
function __ReentrancyGuard_init() internal onlyInitializing {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal onlyInitializing {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
uint256[49] private __gap;
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
__Context_init_unchained();
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal onlyInitializing {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_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);
}
uint256[49] private __gap;
}
interface IERC20Upgradeable {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IHACK is IERC20Upgradeable{
function earnTokens(address to, uint256 amount) external;
function lostTokens(address from, uint256 amount) external;
}
interface ISKILL is IERC20Upgradeable{
function earnTokens(address to, uint256 amount) external;
function lostTokens(address from, uint256 amount) external;
}
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
function transferFrom(address from,
address to,
uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes calldata data) external;
}
contract GAME is OwnableUpgradeable, ReentrancyGuardUpgradeable{
struct StakeNFT{
uint256 cube_id;
uint date_start;
uint8 active;
}
struct StakeToken{
uint date_start;
uint8 active;
uint256 amount;
}
uint8 constant WALLS = 0;
uint8 constant FLOOR = 1;
uint8 constant PC = 2;
uint8 constant TABLE = 3;
uint8 constant CONSOLE =4;
address private _token;
uint256 private _price;
uint256 private _skills_reward;
uint256 private _stake_pool;
uint256 private _liquidity_pool;
uint256 private _levelUpPrice;
IERC721 private _hacker_nft;
IERC721 private _cube_nft;
ISKILL private _skills;
IHACK private _hack;
uint256 private _hacker_base_rewards;
mapping(address => mapping(uint256 => StakeNFT)) private _nft_stakes;
mapping(address => StakeToken) private _token_stakes;
mapping(uint256 => uint8) private _hacker_levels;
mapping(uint256 => mapping(uint8 => uint8)) private _cube_levels;
mapping(uint8 => mapping(uint8 => uint256)) private _cube_rewards;
mapping(uint8 => mapping(uint8 => uint256)) private _cube_upgrade_price;
event NFTStaked(address indexed sender, uint256 indexed hacker_id, uint256 indexed cube_id);
event NFTUnStaked(address indexed sender, uint256 indexed hacker_id, uint256 indexed cube_id);
event TokenStaked(address indexed sender, uint256 amount);
event TokenUnStaked(address indexed sender, uint256 amount);
function initialize() initializer public {
__Ownable_init();
__ReentrancyGuard_init();
_price = 0.03 ether;
_cube_rewards[WALLS][0] = 100; // x1.0
_cube_rewards[WALLS][1] = 110; // x1.1
_cube_rewards[WALLS][2] = 130; // x1.3
_cube_rewards[WALLS][3] = 150; // x1.5
_cube_rewards[WALLS][4] = 200; // x2
_cube_rewards[FLOOR][0] = 100;
_cube_rewards[FLOOR][1] = 110;
_cube_rewards[FLOOR][2] = 130;
_cube_rewards[FLOOR][3] = 150;
_cube_rewards[FLOOR][4] = 200;
_cube_rewards[PC][0] = 0.5 ether;
_cube_rewards[PC][1] = 1.5 ether;
_cube_rewards[PC][2] = 3 ether;
_cube_rewards[PC][3] = 10 ether;
_cube_rewards[PC][4] = 25 ether;
_cube_rewards[TABLE][0] = 0.3 ether;
_cube_rewards[TABLE][1] = 1 ether;
_cube_rewards[TABLE][2] = 3 ether;
_cube_rewards[TABLE][3] = 8 ether;
_cube_rewards[TABLE][4] = 20 ether;
_cube_rewards[CONSOLE][0] = 0.2 ether; // 1%
_cube_rewards[CONSOLE][1] = 1 ether; // 1%
_cube_rewards[CONSOLE][2] = 2 ether; // 1%
_cube_rewards[CONSOLE][3] = 5 ether; // 1%
_cube_rewards[CONSOLE][4] = 15 ether; // 1%
_cube_upgrade_price[WALLS][0] = 0; // x1.0
_cube_upgrade_price[WALLS][1] = 100 ether; // x1.1
_cube_upgrade_price[WALLS][2] = 500 ether; // x1.3
_cube_upgrade_price[WALLS][3] = 1000 ether; // x1.5
_cube_upgrade_price[WALLS][4] = 3000 ether; // x2
_cube_upgrade_price[FLOOR][0] = 0;
_cube_upgrade_price[FLOOR][1] = 100 ether;
_cube_upgrade_price[FLOOR][2] = 500 ether;
_cube_upgrade_price[FLOOR][3] = 1000 ether;
_cube_upgrade_price[FLOOR][4] = 3000 ether;
_cube_upgrade_price[PC][0] = 0;
_cube_upgrade_price[PC][1] = 150 ether;
_cube_upgrade_price[PC][2] = 270 ether;
_cube_upgrade_price[PC][3] = 700 ether;
_cube_upgrade_price[PC][4] = 1750 ether;
_cube_upgrade_price[TABLE][0] = 0 ether;
_cube_upgrade_price[TABLE][1] = 100 ether;
_cube_upgrade_price[TABLE][2] = 270 ether;
_cube_upgrade_price[TABLE][3] = 700 ether;
_cube_upgrade_price[TABLE][4] = 1500 ether;
_cube_upgrade_price[CONSOLE][0] = 0 ether; // 1%
_cube_upgrade_price[CONSOLE][1] = 100 ether; // 1%
_cube_upgrade_price[CONSOLE][2] = 180 ether; // 1%
_cube_upgrade_price[CONSOLE][3] = 450 ether; // 1%
_cube_upgrade_price[CONSOLE][4] = 1200 ether; // 1%
_hacker_base_rewards = 0.05 ether;
_skills_reward = 0.001 ether;
//_levelUpPrice = 0.01 ether;
}
function updateHackerLevels(uint256[] memory ids, uint8[] memory levels) external onlyOwner{
require(levels.length == ids.length,"Error in length");
for(uint i=0;i<ids.length;i++){
_hacker_levels[ids[i]]=levels[i];
}
}
function updateHackerLevel(uint256 id) external nonReentrant{
uint256 need_hack = (1 + _hacker_levels[id] * 5 / 100) * (2 + _hacker_levels[id] / 100);
uint256 need_skill =10 * (1 + _hacker_levels[id] * 5 / 100) * (2 + _hacker_levels[id] / 100);
require(_hack.allowance(msg.sender, address(this)) >= need_hack, "Not enough $HACK");
require(_skills.allowance(msg.sender, address(this)) >= need_skill, "Not enough $SKILL");
require(_hacker_nft.ownerOf(id) == msg.sender ,"Not owner of the NFT");
_hacker_levels[id] +=1;
_hack.transferFrom(msg.sender, address(this), need_hack);
_skills.transferFrom(msg.sender, address(this), need_skill);
}
function updateCubeLevel(uint256 id, uint8 upgrade) external nonReentrant{
uint256 need_hack = _cube_upgrade_price[upgrade][_cube_levels[id][upgrade]];
require(upgrade >=0 && upgrade <5, "Illegal upgrade type");
require(_hack.allowance(msg.sender, address(this)) >= need_hack, "Not enough $HACK");
require(_hacker_nft.ownerOf(id) == msg.sender ,"Not owner of the NFT");
_cube_levels[id][upgrade] +=1;
_hack.transferFrom(msg.sender, address(this), need_hack);
}
function updateSkillContract(address token) external onlyOwner{
_skills = ISKILL(token);
}
function updateHackerNTFContract(address nft) external onlyOwner{
_hacker_nft = IERC721(nft);
}
function updateCubeNTFContract(address nft) external onlyOwner{
_cube_nft = IERC721(nft);
}
function updateHackContract(address token) external onlyOwner{
_hack = IHACK(token);
}
function stakeHack(uint256 amount) external nonReentrant{
require(_hack.balanceOf(msg.sender) >= amount, "Amount is more than balance");
(msg.sender, address(this), amount);
_token_stakes[msg.sender].date_start=block.timestamp;
_token_stakes[msg.sender].active=1;
_token_stakes[msg.sender].amount=amount;
emit TokenStaked(msg.sender, amount);
}
function unstakeHack() external nonReentrant{
require(address(_skills) != address(0x0), "Skills not activated");
require(_token_stakes[msg.sender].active == 1, "Stake is not active");
_hack.earnTokens(msg.sender, _token_stakes[msg.sender].amount);
uint256 days_past = (block.timestamp - _token_stakes[msg.sender].date_start) / 86400;
_token_stakes[msg.sender].active=0;
emit TokenStaked(msg.sender, _token_stakes[msg.sender].amount);
uint256 reward = days_past * _skills_reward;
_stake_pool-=_token_stakes[msg.sender].amount;
_token_stakes[msg.sender].amount=0;
if (days_past == 0){
_hack.lostTokens(msg.sender, _hack.balanceOf(msg.sender) * 75 / 100);
}else{
if (_skills.balanceOf(address(this)) >= reward){
_skills.transfer(msg.sender, reward);
}else{
_skills.transfer(msg.sender, _skills.balanceOf(address(this)));
}
}
}
function stakeHacker(uint256 hacker_id) external nonReentrant{
require(_hacker_nft.ownerOf(hacker_id) == msg.sender, "Not owner of token");
_hacker_nft.transferFrom(msg.sender, address(this), hacker_id);
_nft_stakes[msg.sender][hacker_id].date_start=block.timestamp;
_nft_stakes[msg.sender][hacker_id].active=1;
_nft_stakes[msg.sender][hacker_id].cube_id=0x0;
emit NFTStaked(msg.sender, hacker_id,0x0);
}
function stakeHackerAndCube(uint256 hacker_id, uint256 cube_id) external nonReentrant{
require(_hacker_nft.ownerOf(hacker_id) == msg.sender, "Not owner of HACKER token");
require(_cube_nft.ownerOf(cube_id) == msg.sender, "Not owner of CUBE token");
_hacker_nft.transferFrom(msg.sender, address(this), hacker_id);
_cube_nft.transferFrom(msg.sender, address(this), cube_id);
_nft_stakes[msg.sender][hacker_id].date_start=block.timestamp;
_nft_stakes[msg.sender][cube_id].active=1;
emit NFTStaked(msg.sender, hacker_id,cube_id);
}
function unstakeHacker(uint256 hacker_id)external nonReentrant{
uint256 hack_reward = 0;
uint256 skill_reward = 0;
require(_nft_stakes[msg.sender][hacker_id].active == 1, "Token is not staked");
_nft_stakes[msg.sender][hacker_id].active = 0;
_hacker_nft.transferFrom(address(this), msg.sender, hacker_id);
uint256 days_past = (block.timestamp - _nft_stakes[msg.sender][hacker_id].date_start) / 86400;
hack_reward = days_past * _hacker_base_rewards;
if (_nft_stakes[msg.sender][hacker_id].cube_id != 0x0){
uint256 cube_id = _nft_stakes[msg.sender][hacker_id].cube_id;
_cube_nft.transferFrom(address(this), msg.sender, cube_id);
hack_reward += _cube_rewards[WALLS][_cube_levels[cube_id][WALLS]];
hack_reward += _cube_rewards[FLOOR][_cube_levels[cube_id][FLOOR]];
hack_reward += _cube_rewards[PC][_cube_levels[cube_id][PC]];
hack_reward += _cube_rewards[TABLE][_cube_levels[cube_id][TABLE]];
hack_reward += _cube_rewards[CONSOLE][_cube_levels[cube_id][CONSOLE]];
}
if (days_past == 0){
_hack.lostTokens(msg.sender, _hack.balanceOf(msg.sender) * 75 / 100);
}else{
_hack.earnTokens(msg.sender, hack_reward);
_skills.earnTokens(msg.sender, skill_reward);
}
emit NFTUnStaked(msg.sender, hacker_id,_nft_stakes[msg.sender][hacker_id].cube_id);
}
}
| 126,053 | 10,748 |
3a1f891b146939fa034dc0626ffb3133ca162dcd63f3c1776763b066cd1518f4
| 27,523 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TQ/TQKE95przRqPijTRb59nKwhRCwyENkFzCt_RKTXBridge.sol
| 3,033 | 11,697 |
//SourceUnit: RKTXBridge.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function _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 ERC20 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() public {
_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 virtual{
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _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);
}
}
contract RKTXBridge{
uint256 minAmount = 10 ** 2 * 10 ** 18;
ERC20 public erc20;
address public ownerAddress;
event _transferRKTX(uint netType, address sender, string receiver, uint256 amount);
event _transferToUser(address account, uint256 amount);
constructor(ERC20 _erc20, address owner) public {
erc20 = _erc20;
ownerAddress = owner;
}
modifier onlyOwner() {
require(ownerAddress == msg.sender, 'Ownable: caller is not the owner');
_;
}
function transferRKTX(uint netType, string memory receiver, uint256 amount) payable public {
require(amount > 0, "Can not transfer zero amount");
require(amount >= minAmount, "Invalid tranfer amount");
payable(ownerAddress).transfer(address(this).balance); // send fee to owner
erc20.transferFrom(msg.sender, ownerAddress, amount);
emit _transferRKTX(netType, msg.sender, receiver, amount);
}
function transferOwnership(address newOwner) public onlyOwner{
ownerAddress = newOwner;
}
function changeRKTX(ERC20 _erc20) public onlyOwner{
erc20 = _erc20;
}
}
| 290,228 | 10,749 |
094d1d7d1b4516989ca278c94143b60adc86822f8352253c8ebc8799cf6c127f
| 19,923 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xb41bd4c99da73510d9e081c5fadbe7a27ac1f814.sol
| 4,417 | 19,542 |
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
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 IWETH {
function deposit() external payable;
function withdraw(uint wad) external;
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address);
}
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 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 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 swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IIdeaToken is IERC20 {
function initialize(string calldata __name, address owner) external;
function mint(address account, uint256 amount) external;
function burn(address account, uint256 amount) external;
}
interface IIdeaTokenNameVerifier {
function verifyTokenName(string calldata name) external pure returns (bool);
}
struct IDPair {
bool exists;
uint marketID;
uint tokenID;
}
struct TokenInfo {
bool exists;
uint id;
string name;
IIdeaToken ideaToken;
}
struct MarketDetails {
bool exists;
uint id;
string name;
IIdeaTokenNameVerifier nameVerifier;
uint numTokens;
uint baseCost;
uint priceRise;
uint hatchTokens;
uint tradingFeeRate;
uint platformFeeRate;
bool allInterestToPlatform;
}
interface IIdeaTokenFactory {
function addMarket(string calldata marketName, address nameVerifier,
uint baseCost, uint priceRise, uint hatchTokens,
uint tradingFeeRate, uint platformFeeRate, bool allInterestToPlatform) external;
function addToken(string calldata tokenName, uint marketID, address lister) external;
function isValidTokenName(string calldata tokenName, uint marketID) external view returns (bool);
function getMarketIDByName(string calldata marketName) external view returns (uint);
function getMarketDetailsByID(uint marketID) external view returns (MarketDetails memory);
function getMarketDetailsByName(string calldata marketName) external view returns (MarketDetails memory);
function getMarketDetailsByTokenAddress(address ideaToken) external view returns (MarketDetails memory);
function getNumMarkets() external view returns (uint);
function getTokenIDByName(string calldata tokenName, uint marketID) external view returns (uint);
function getTokenInfo(uint marketID, uint tokenID) external view returns (TokenInfo memory);
function getTokenIDPair(address token) external view returns (IDPair memory);
function setTradingFee(uint marketID, uint tradingFeeRate) external;
function setPlatformFee(uint marketID, uint platformFeeRate) external;
function setNameVerifier(uint marketID, address nameVerifier) external;
}
struct CostAndPriceAmounts {
uint total;
uint raw;
uint tradingFee;
uint platformFee;
}
interface IIdeaTokenExchange {
function sellTokens(address ideaToken, uint amount, uint minPrice, address recipient) external;
function getPriceForSellingTokens(address ideaToken, uint amount) external view returns (uint);
function getPricesForSellingTokens(MarketDetails memory marketDetails, uint supply, uint amount, bool feesDisabled) external pure returns (CostAndPriceAmounts memory);
function buyTokens(address ideaToken, uint amount, uint fallbackAmount, uint cost, address recipient) external;
function getCostForBuyingTokens(address ideaToken, uint amount) external view returns (uint);
function getCostsForBuyingTokens(MarketDetails memory marketDetails, uint supply, uint amount, bool feesDisabled) external pure returns (CostAndPriceAmounts memory);
function setTokenOwner(address ideaToken, address owner) external;
function setPlatformOwner(uint marketID, address owner) external;
function withdrawTradingFee() external;
function withdrawTokenInterest(address token) external;
function withdrawPlatformInterest(uint marketID) external;
function withdrawPlatformFee(uint marketID) external;
function getInterestPayable(address token) external view returns (uint);
function getPlatformInterestPayable(uint marketID) external view returns (uint);
function getPlatformFeePayable(uint marketID) external view returns (uint);
function getTradingFeePayable() external view returns (uint);
function setAuthorizer(address authorizer) external;
function isTokenFeeDisabled(address ideaToken) external view returns (bool);
function setTokenFeeKillswitch(address ideaToken, bool set) external;
}
struct LockedEntry {
uint lockedUntil;
uint lockedAmount;
}
interface IIdeaTokenVault {
function lock(address ideaToken, uint amount, uint duration, address recipient) external;
function withdraw(address ideaToken, uint[] calldata untils, address recipient) external;
function getLockedEntries(address ideaToken, address user, uint maxEntries) external view returns (LockedEntry[] memory);
}
contract MultiAction {
IIdeaTokenExchange _ideaTokenExchange;
IIdeaTokenFactory _ideaTokenFactory;
IIdeaTokenVault _ideaTokenVault;
IERC20 public _dai;
IUniswapV2Factory public _uniswapV2Factory;
IUniswapV2Router02 public _uniswapV2Router02;
IWETH public _weth;
constructor(address ideaTokenExchange,
address ideaTokenFactory,
address ideaTokenVault,
address dai,
address uniswapV2Router02,
address weth) public {
require(ideaTokenExchange != address(0) &&
ideaTokenFactory != address(0) &&
ideaTokenVault != address(0) &&
dai != address(0) &&
uniswapV2Router02 != address(0) &&
weth != address(0),
"invalid-params");
_ideaTokenExchange = IIdeaTokenExchange(ideaTokenExchange);
_ideaTokenFactory = IIdeaTokenFactory(ideaTokenFactory);
_ideaTokenVault = IIdeaTokenVault(ideaTokenVault);
_dai = IERC20(dai);
_uniswapV2Router02 = IUniswapV2Router02(uniswapV2Router02);
_uniswapV2Factory = IUniswapV2Factory(IUniswapV2Router02(uniswapV2Router02).factory());
_weth = IWETH(weth);
}
function convertAndBuy(address inputCurrency,
address ideaToken,
uint amount,
uint fallbackAmount,
uint cost,
uint lockDuration,
address recipient) external payable {
IIdeaTokenExchange exchange = _ideaTokenExchange;
uint buyAmount = amount;
uint buyCost = exchange.getCostForBuyingTokens(ideaToken, amount);
uint requiredInput = getInputForOutputInternal(inputCurrency, address(_dai), buyCost);
if(requiredInput > cost) {
buyCost = exchange.getCostForBuyingTokens(ideaToken, fallbackAmount);
requiredInput = getInputForOutputInternal(inputCurrency, address(_dai), buyCost);
require(requiredInput <= cost, "slippage");
buyAmount = fallbackAmount;
}
convertAndBuyInternal(inputCurrency, ideaToken, requiredInput, buyAmount, buyCost, lockDuration, recipient);
}
function sellAndConvert(address outputCurrency,
address ideaToken,
uint amount,
uint minPrice,
address payable recipient) external {
IIdeaTokenExchange exchange = _ideaTokenExchange;
IERC20 dai = _dai;
uint sellPrice = exchange.getPriceForSellingTokens(ideaToken, amount);
uint output = getOutputForInputInternal(address(dai), outputCurrency, sellPrice);
require(output >= minPrice, "slippage");
pullERC20Internal(ideaToken, msg.sender, amount);
exchange.sellTokens(ideaToken, amount, sellPrice, address(this));
convertInternal(address(dai), outputCurrency, sellPrice, output);
if(outputCurrency == address(0)) {
recipient.transfer(output);
} else {
require(IERC20(outputCurrency).transfer(recipient, output), "transfer");
}
}
function convertAddAndBuy(string calldata tokenName,
uint marketID,
address inputCurrency,
uint amount,
uint fallbackAmount,
uint cost,
uint lockDuration,
address recipient) external payable {
IERC20 dai = _dai;
uint buyAmount = amount;
uint buyCost = getBuyCostFromZeroSupplyInternal(marketID, buyAmount);
uint requiredInput = getInputForOutputInternal(inputCurrency, address(dai), buyCost);
if(requiredInput > cost) {
buyCost = getBuyCostFromZeroSupplyInternal(marketID, fallbackAmount);
requiredInput = getInputForOutputInternal(inputCurrency, address(dai), buyCost);
require(requiredInput <= cost, "slippage");
buyAmount = fallbackAmount;
}
address ideaToken = addTokenInternal(tokenName, marketID);
convertAndBuyInternal(inputCurrency, ideaToken, requiredInput, buyAmount, buyCost, lockDuration, recipient);
}
function addAndBuy(string calldata tokenName, uint marketID, uint amount, uint lockDuration, address recipient) external {
uint cost = getBuyCostFromZeroSupplyInternal(marketID, amount);
pullERC20Internal(address(_dai), msg.sender, cost);
address ideaToken = addTokenInternal(tokenName, marketID);
if(lockDuration > 0) {
buyAndLockInternal(ideaToken, amount, cost, lockDuration, recipient);
} else {
buyInternal(ideaToken, amount, cost, recipient);
}
}
function buyAndLock(address ideaToken, uint amount, uint fallbackAmount, uint cost, uint lockDuration, address recipient) external {
IIdeaTokenExchange exchange = _ideaTokenExchange;
uint buyAmount = amount;
uint buyCost = exchange.getCostForBuyingTokens(ideaToken, amount);
if(buyCost > cost) {
buyCost = exchange.getCostForBuyingTokens(ideaToken, fallbackAmount);
require(buyCost <= cost, "slippage");
buyAmount = fallbackAmount;
}
pullERC20Internal(address(_dai), msg.sender, buyCost);
buyAndLockInternal(ideaToken, buyAmount, buyCost, lockDuration, recipient);
}
function convertAndBuyInternal(address inputCurrency, address ideaToken, uint input, uint amount, uint cost, uint lockDuration, address recipient) internal {
if(inputCurrency != address(0)) {
pullERC20Internal(inputCurrency, msg.sender, input);
}
convertInternal(inputCurrency, address(_dai), input, cost);
if(lockDuration > 0) {
buyAndLockInternal(ideaToken, amount, cost, lockDuration, recipient);
} else {
buyInternal(ideaToken, amount, cost, recipient);
}
if(address(this).balance > 0) {
msg.sender.transfer(address(this).balance);
}
}
function buyAndLockInternal(address ideaToken, uint amount, uint cost, uint lockDuration, address recipient) internal {
IIdeaTokenVault vault = _ideaTokenVault;
buyInternal(ideaToken, amount, cost, address(this));
require(IERC20(ideaToken).approve(address(vault), amount), "approve");
vault.lock(ideaToken, amount, lockDuration, recipient);
}
function buyInternal(address ideaToken, uint amount, uint cost, address recipient) internal {
IIdeaTokenExchange exchange = _ideaTokenExchange;
require(_dai.approve(address(exchange), cost), "approve");
exchange.buyTokens(ideaToken, amount, amount, cost, recipient);
}
function addTokenInternal(string memory tokenName, uint marketID) internal returns (address) {
IIdeaTokenFactory factory = _ideaTokenFactory;
factory.addToken(tokenName, marketID, msg.sender);
return address(factory.getTokenInfo(marketID, factory.getTokenIDByName(tokenName, marketID)).ideaToken);
}
function pullERC20Internal(address token, address from, uint amount) internal {
require(IERC20(token).allowance(from, address(this)) >= amount, "insufficient-allowance");
require(IERC20(token).transferFrom(from, address(this), amount), "transfer");
}
function getBuyCostFromZeroSupplyInternal(uint marketID, uint amount) internal view returns (uint) {
MarketDetails memory marketDetails = _ideaTokenFactory.getMarketDetailsByID(marketID);
require(marketDetails.exists, "invalid-market");
return _ideaTokenExchange.getCostsForBuyingTokens(marketDetails, 0, amount, false).total;
}
function getInputForOutputInternal(address inputCurrency, address outputCurrency, uint outputAmount) internal view returns (uint) {
address[] memory path = getPathInternal(inputCurrency, outputCurrency);
return _uniswapV2Router02.getAmountsIn(outputAmount, path)[0];
}
function getOutputForInputInternal(address inputCurrency, address outputCurrency, uint inputAmount) internal view returns (uint) {
address[] memory path = getPathInternal(inputCurrency, outputCurrency);
uint[] memory amountsOut = _uniswapV2Router02.getAmountsOut(inputAmount, path);
return amountsOut[amountsOut.length - 1];
}
function getPathInternal(address inputCurrency, address outputCurrency) internal view returns (address[] memory) {
address wethAddress = address(_weth);
address updatedInputCurrency = inputCurrency == address(0) ? wethAddress : inputCurrency;
address updatedOutputCurrency = outputCurrency == address(0) ? wethAddress : outputCurrency;
IUniswapV2Factory uniswapFactory = _uniswapV2Factory;
if(uniswapFactory.getPair(updatedInputCurrency, updatedOutputCurrency) != address(0)) {
address[] memory path = new address[](2);
path[0] = updatedInputCurrency;
path[1] = updatedOutputCurrency;
return path;
}
require(uniswapFactory.getPair(updatedInputCurrency, wethAddress) != address(0) &&
uniswapFactory.getPair(wethAddress, updatedOutputCurrency) != address(0),
"no-path");
address[] memory path = new address[](3);
path[0] = updatedInputCurrency;
path[1] = wethAddress;
path[2] = updatedOutputCurrency;
return path;
}
function convertInternal(address inputCurrency, address outputCurrency, uint inputAmount, uint outputAmount) internal {
IWETH weth = _weth;
IUniswapV2Router02 router = _uniswapV2Router02;
address[] memory path = getPathInternal(inputCurrency, outputCurrency);
IERC20 inputERC20;
if(inputCurrency == address(0)) {
weth.deposit{value: inputAmount}();
inputERC20 = IERC20(address(weth));
} else {
inputERC20 = IERC20(inputCurrency);
}
require(inputERC20.approve(address(router), inputAmount), "router-approve");
router.swapExactTokensForTokensSupportingFeeOnTransferTokens(inputAmount,
outputAmount,
path,
address(this),
now + 1);
if(outputCurrency == address(0)) {
weth.withdraw(outputAmount);
}
}
receive() external payable {
require(msg.sender == address(_weth));
}
}
| 275,228 | 10,750 |
50bb509e95dda51cac57a1a0e460f49f762a23fd13ec39d3831b219a9000013c
| 21,411 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0xf3C8Ed6C721774C022c530E813a369dFe78a6E85.sol
| 4,225 | 16,423 |
pragma solidity ^0.4.2;
interface KittyCore {
function ownerOf (uint256 _tokenId) external view returns (address owner);
function getKitty (uint256 _id) external view returns (bool isGestating, bool isReady, uint256 cooldownIndex, uint256 nextActionAt, uint256 siringWithId, uint256 birthTime, uint256 matronId, uint256 sireId, uint256 generation, uint256 genes);
}
interface SaleClockAuction {
function getCurrentPrice (uint256 _tokenId) external view returns (uint256);
function getAuction (uint256 _tokenId) external view returns (address seller, uint256 startingPrice, uint256 endingPrice, uint256 duration, uint256 startedAt);
}
contract ERC721 {
// Required methods
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) external view returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function allowance(address _owner, address _spender) view returns (uint remaining);
function takeOwnership(uint256 _tokenId) external;
// Events
event Transfer(address indexed from, address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 tokenId);
function name() public view returns (string);
function symbol() public view returns (string);
// function tokensOfOwner(address _owner) external view returns (uint256[] tokenIds);
// ERC-165 Compatibility (https://github.com/ethereum/EIPs/issues/165)
function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}
contract CryptoSprites is ERC721 {
address public owner;
address KittyCoreAddress = 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d;
address SaleClockAuctionAddress = 0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C;
address charityAddress = 0xb30cb3b3E03A508Db2A0a3e07BA1297b47bb0fb1;
uint public etherForOwner;
uint public etherForCharity;
uint public ownerCut = 15; // 1.5% (15/1000 - see the buySprite() function) of Sprite sales go to owner of this contract
uint public charityCut = 15; // 1.5% of Sprite sales also go to an established charity (Heifer International)
uint public featurePrice = 10**16; // 0.01 Ether to feature a sprite
// The default price of a Sprite may easily increase later to be more than 10%
uint public priceMultiplier = 1;
uint public priceDivider = 10;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function CryptoSprites() {
owner = msg.sender;
}
uint[] public featuredSprites;
uint[] public allPurchasedSprites;
uint public totalFeatures;
uint public totalBuys;
struct BroughtSprites {
address owner;
uint spriteImageID;
bool forSale;
uint price;
uint timesTraded;
bool featured;
}
mapping (uint => BroughtSprites) public broughtSprites;
// This may include Sprites the user previously owned but doesn't anymore
mapping (address => uint[]) public spriteOwningHistory;
mapping (address => uint) public numberOfSpritesOwnedByUser;
mapping (address => mapping(address => mapping(uint256 => bool))) public addressToReceiverToAllowedSprite;
mapping (address => mapping(address => uint256)) public addressToReceiverToAmountAllowed;
bytes4 constant InterfaceSignature_ERC165 = bytes4(keccak256('supportsInterface(bytes4)'));
bytes4 constant InterfaceSignature_ERC721 =
bytes4(keccak256('totalSupply()')) ^
bytes4(keccak256('balanceOf(address)')) ^
bytes4(keccak256('ownerOf(uint256)')) ^
bytes4(keccak256('approve(address,uint256)')) ^
bytes4(keccak256('transfer(address,uint256)')) ^
bytes4(keccak256('transferFrom(address,address,uint256)'));
function() payable {
etherForOwner += msg.value;
}
function adjustDefaultSpritePrice (uint _priceMultiplier, uint _priceDivider) onlyOwner {
require (_priceMultiplier > 0);
require (_priceDivider > 0);
priceMultiplier = _priceMultiplier;
priceDivider = _priceDivider;
}
function adjustCut (uint _ownerCut, uint _charityCut) onlyOwner {
require (_ownerCut + _charityCut < 51);
ownerCut = _ownerCut;
charityCut = _charityCut;
}
function adjustFeaturePrice (uint _featurePrice) onlyOwner {
require (_featurePrice > 0);
featurePrice = _featurePrice;
}
function withdraw() onlyOwner {
owner.transfer(etherForOwner);
charityAddress.transfer(etherForCharity);
etherForOwner = 0;
etherForCharity = 0;
}
function changeOwner (address _owner) onlyOwner {
owner = _owner;
}
function featureSprite (uint spriteId) payable {
// Do not need to require user to be the owner of a Sprite to feature it
// require (msg.sender == broughtSprites[spriteId].owner);
require (msg.value == featurePrice);
broughtSprites[spriteId].featured = true;
if (broughtSprites[spriteId].timesTraded == 0) {
var (kittyOwner,,,,) = SaleClockAuction(SaleClockAuctionAddress).getAuction(spriteId);
uint priceIfAny = SaleClockAuction(SaleClockAuctionAddress).getCurrentPrice(spriteId);
address kittyOwnerNotForSale = KittyCore(KittyCoreAddress).ownerOf(spriteId);
if (priceIfAny > 0 && msg.sender == kittyOwner) {
broughtSprites[spriteId].price = priceIfAny * priceMultiplier / priceDivider;
broughtSprites[spriteId].forSale = true;
broughtSprites[spriteId].owner = kittyOwner;
numberOfSpritesOwnedByUser[msg.sender]++;
} else if (kittyOwnerNotForSale == msg.sender) {
// User featuring the sprite owns its kitty, but hasn't listed the kitty for sale
broughtSprites[spriteId].owner = kittyOwnerNotForSale;
numberOfSpritesOwnedByUser[msg.sender]++;
}
broughtSprites[spriteId].spriteImageID = uint(block.blockhash(block.number-1))%360 + 1;
}
totalFeatures++;
etherForOwner += msg.value;
featuredSprites.push(spriteId);
}
function calculatePrice (uint kittyId) view returns (uint) {
uint priceIfAny = SaleClockAuction(SaleClockAuctionAddress).getCurrentPrice(kittyId);
var _ownerCut = ((priceIfAny / 1000) * ownerCut) * priceMultiplier / priceDivider;
var _charityCut = ((priceIfAny / 1000) * charityCut) * priceMultiplier / priceDivider;
return (priceIfAny * priceMultiplier / priceDivider) + _ownerCut + _charityCut;
}
function buySprite (uint spriteId) payable {
uint _ownerCut;
uint _charityCut;
if (broughtSprites[spriteId].forSale == true) {
_ownerCut = ((broughtSprites[spriteId].price / 1000) * ownerCut);
_charityCut = ((broughtSprites[spriteId].price / 1000) * charityCut);
require (msg.value == broughtSprites[spriteId].price + _ownerCut + _charityCut);
broughtSprites[spriteId].owner.transfer(broughtSprites[spriteId].price);
numberOfSpritesOwnedByUser[broughtSprites[spriteId].owner]--;
if (broughtSprites[spriteId].timesTraded == 0) {
// Featured sprite that is being purchased for the first time
allPurchasedSprites.push(spriteId);
}
Transfer (broughtSprites[spriteId].owner, msg.sender, spriteId);
} else {
require (broughtSprites[spriteId].timesTraded == 0);
require (broughtSprites[spriteId].price == 0);
// Here we are looking up the price of the Sprite's corresponding Kitty
uint priceIfAny = SaleClockAuction(SaleClockAuctionAddress).getCurrentPrice(spriteId);
require (priceIfAny > 0);
_ownerCut = ((priceIfAny / 1000) * ownerCut) * priceMultiplier / priceDivider;
_charityCut = ((priceIfAny / 1000) * charityCut) * priceMultiplier / priceDivider;
// Crypto Kitty prices decrease every few seconds by a fractional amount, so use >=
require (msg.value >= (priceIfAny * priceMultiplier / priceDivider) + _ownerCut + _charityCut);
// Get the owner of the Kitty for sale
var (kittyOwner,,,,) = SaleClockAuction(SaleClockAuctionAddress).getAuction(spriteId);
kittyOwner.transfer(priceIfAny * priceMultiplier / priceDivider);
allPurchasedSprites.push(spriteId);
broughtSprites[spriteId].spriteImageID = uint(block.blockhash(block.number-1))%360 + 1; // Random number to determine what image/character the sprite will be
Transfer (kittyOwner, msg.sender, spriteId);
}
totalBuys++;
spriteOwningHistory[msg.sender].push(spriteId);
numberOfSpritesOwnedByUser[msg.sender]++;
broughtSprites[spriteId].owner = msg.sender;
broughtSprites[spriteId].forSale = false;
broughtSprites[spriteId].timesTraded++;
broughtSprites[spriteId].featured = false;
etherForOwner += _ownerCut;
etherForCharity += _charityCut;
}
// Also used to adjust price if already for sale
function listSpriteForSale (uint spriteId, uint price) {
require (price > 0);
if (broughtSprites[spriteId].owner != msg.sender) {
require (broughtSprites[spriteId].timesTraded == 0);
// This will be the owner of a Crypto Kitty, who can control the price of their unbrought Sprite
var (kittyOwner,,,,) = SaleClockAuction(SaleClockAuctionAddress).getAuction(spriteId);
if (kittyOwner != msg.sender) {
address kittyOwnerNotForSale = KittyCore(KittyCoreAddress).ownerOf(spriteId);
require (kittyOwnerNotForSale == msg.sender);
}
broughtSprites[spriteId].owner = msg.sender;
broughtSprites[spriteId].spriteImageID = uint(block.blockhash(block.number-1))%360 + 1;
}
broughtSprites[spriteId].forSale = true;
broughtSprites[spriteId].price = price;
}
function removeSpriteFromSale (uint spriteId) {
if (broughtSprites[spriteId].owner != msg.sender) {
require (broughtSprites[spriteId].timesTraded == 0);
var (kittyOwner,,,,) = SaleClockAuction(SaleClockAuctionAddress).getAuction(spriteId);
if (kittyOwner != msg.sender) {
address kittyOwnerNotForSale = KittyCore(KittyCoreAddress).ownerOf(spriteId);
require (kittyOwnerNotForSale == msg.sender);
}
broughtSprites[spriteId].price = 1;
}
broughtSprites[spriteId].forSale = false;
}
function featuredSpritesLength() view external returns (uint) {
return featuredSprites.length;
}
function usersSpriteOwningHistory (address user) view external returns (uint[]) {
return spriteOwningHistory[user];
}
function lookupSprite (uint spriteId) view external returns (address, uint, bool, uint, uint, bool) {
return (broughtSprites[spriteId].owner, broughtSprites[spriteId].spriteImageID, broughtSprites[spriteId].forSale, broughtSprites[spriteId].price, broughtSprites[spriteId].timesTraded, broughtSprites[spriteId].featured);
}
function lookupFeaturedSprites (uint _index) view external returns (uint) {
return featuredSprites[_index];
}
function lookupAllSprites (uint _index) view external returns (uint) {
return allPurchasedSprites[_index];
}
function lookupKitty (uint kittyId) view returns (address, uint, address) {
var (kittyOwner,,,,) = SaleClockAuction(SaleClockAuctionAddress).getAuction(kittyId);
uint priceIfAny = SaleClockAuction(SaleClockAuctionAddress).getCurrentPrice(kittyId);
address kittyOwnerNotForSale = KittyCore(KittyCoreAddress).ownerOf(kittyId);
return (kittyOwner, priceIfAny, kittyOwnerNotForSale);
}
function lookupKittyDetails1 (uint kittyId) view returns (bool, bool, uint, uint, uint) {
var (isGestating, isReady, cooldownIndex, nextActionAt, siringWithId,,,,,) = KittyCore(KittyCoreAddress).getKitty(kittyId);
return (isGestating, isReady, cooldownIndex, nextActionAt, siringWithId);
}
function lookupKittyDetails2 (uint kittyId) view returns (uint, uint, uint, uint, uint) {
var(,,,,,birthTime, matronId, sireId, generation, genes) = KittyCore(KittyCoreAddress).getKitty(kittyId);
return (birthTime, matronId, sireId, generation, genes);
}
// ERC-721 required functions below
string public name = 'Crypto Sprites';
string public symbol = 'CRS';
uint8 public decimals = 0; // Sprites are non-fungible, ie. can't be divided into pieces
function name() public view returns (string) {
return name;
}
function symbol() public view returns (string) {
return symbol;
}
function totalSupply() public view returns (uint) {
return allPurchasedSprites.length;
}
function balanceOf (address _owner) public view returns (uint) {
return numberOfSpritesOwnedByUser[_owner];
}
function ownerOf (uint _tokenId) external view returns (address){
return broughtSprites[_tokenId].owner;
}
function approve (address _to, uint256 _tokenId) external {
require (broughtSprites[_tokenId].owner == msg.sender);
require (addressToReceiverToAllowedSprite[msg.sender][_to][_tokenId] == false);
addressToReceiverToAllowedSprite[msg.sender][_to][_tokenId] = true;
addressToReceiverToAmountAllowed[msg.sender][_to]++;
Approval (msg.sender, _to, _tokenId);
}
function disapprove (address _to, uint256 _tokenId) external {
require (broughtSprites[_tokenId].owner == msg.sender);
require (addressToReceiverToAllowedSprite[msg.sender][_to][_tokenId] == true); // Else the next line may be 0 - 1 and underflow
addressToReceiverToAmountAllowed[msg.sender][_to]--;
addressToReceiverToAllowedSprite[msg.sender][_to][_tokenId] = false;
}
// Not strictly necessary - this can be done with transferFrom() as well
function takeOwnership (uint256 _tokenId) external {
require (addressToReceiverToAllowedSprite[broughtSprites[_tokenId].owner][msg.sender][_tokenId] == true);
addressToReceiverToAllowedSprite[broughtSprites[_tokenId].owner][msg.sender][_tokenId] = false;
addressToReceiverToAmountAllowed[broughtSprites[_tokenId].owner][msg.sender]--;
numberOfSpritesOwnedByUser[broughtSprites[_tokenId].owner]--;
numberOfSpritesOwnedByUser[msg.sender]++;
spriteOwningHistory[msg.sender].push(_tokenId);
Transfer (broughtSprites[_tokenId].owner, msg.sender, _tokenId);
broughtSprites[_tokenId].owner = msg.sender;
}
function transfer (address _to, uint _tokenId) external {
require (broughtSprites[_tokenId].owner == msg.sender);
broughtSprites[_tokenId].owner = _to;
numberOfSpritesOwnedByUser[msg.sender]--;
numberOfSpritesOwnedByUser[_to]++;
spriteOwningHistory[_to].push(_tokenId);
Transfer (msg.sender, _to, _tokenId);
}
function transferFrom (address _from, address _to, uint256 _tokenId) external {
require (addressToReceiverToAllowedSprite[_from][msg.sender][_tokenId] == true);
require (broughtSprites[_tokenId].owner == _from);
addressToReceiverToAllowedSprite[_from][msg.sender][_tokenId] = false;
addressToReceiverToAmountAllowed[_from][msg.sender]--;
numberOfSpritesOwnedByUser[_from]--;
numberOfSpritesOwnedByUser[_to]++;
spriteOwningHistory[_to].push(_tokenId);
broughtSprites[_tokenId].owner = _to;
Transfer (_from, _to, _tokenId);
}
function allowance (address _owner, address _spender) view returns (uint) {
return addressToReceiverToAmountAllowed[_owner][_spender];
}
function supportsInterface (bytes4 _interfaceID) external view returns (bool) {
return ((_interfaceID == InterfaceSignature_ERC165) || (_interfaceID == InterfaceSignature_ERC721));
}
}
| 335,739 | 10,751 |
fd1074c8d7cc7fef049d80eab29454b4dc0e71605db6101584fd5a39224b4bcb
| 18,896 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0x3fab1c4216e401de80cef4ac5387452d16314c6e.sol
| 3,651 | 12,389 |
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;
}
}
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 BurritoToken is ERC721, Ownable {
using SafeMath for uint256;
// Total amount of tokens
uint256 private totalTokens;
uint256[] private listed;
uint256 public devOwed;
uint256 public poolTotal;
uint256 public lastPurchase;
// Burrito Data
mapping (uint256 => Burrito) public burritoData;
// 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 BurritoPurchased(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;
// Dev
uint256 public devCutPercentage = 4;
// Struct to store Burrito Data
struct Burrito {
uint256 startingPrice; // Price the item started at.
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 burrito has withdrawn from the pool.
address owner; // Current owner of the item.
}
function createListing(uint256 _tokenId, uint256 _startingPrice, uint256 _payoutPercentage, address _owner) onlyOwner() public {
// make sure price > 0
require(_startingPrice > 0);
// make sure token hasn't been used yet
require(burritoData[_tokenId].price == 0);
// create new token
Burrito storage newBurrito = burritoData[_tokenId];
newBurrito.owner = _owner;
newBurrito.price = getNextPrice(_startingPrice);
newBurrito.lastPrice = _startingPrice;
newBurrito.payout = _payoutPercentage;
newBurrito.startingPrice = _startingPrice;
// store burrito in storage
listed.push(_tokenId);
// mint new token
_mint(_owner, _tokenId);
}
function createMultiple (uint256[] _itemIds, uint256[] _prices, uint256[] _payouts, address[] _owners) onlyOwner() external {
for (uint256 i = 0; i < _itemIds.length; i++) {
createListing(_itemIds[i], _prices[i], _payouts[i], _owners[i]);
}
}
function getNextPrice (uint256 _price) private view returns (uint256 _nextPrice) {
if (_price < firstCap) {
return _price.mul(200).div(95);
} else if (_price < secondCap) {
return _price.mul(135).div(96);
} else if (_price < thirdCap) {
return _price.mul(125).div(97);
} else if (_price < finalCap) {
return _price.mul(117).div(97);
} else {
return _price.mul(115).div(98);
}
}
function calculatePoolCut (uint256 _price) public view returns (uint256 _poolCut) {
if (_price < firstCap) {
return _price.mul(10).div(100); // 5%
} else if (_price < secondCap) {
return _price.mul(9).div(100); // 4%
} else if (_price < thirdCap) {
return _price.mul(8).div(100); // 3%
} else if (_price < finalCap) {
return _price.mul(7).div(100); // 3%
} else {
return _price.mul(5).div(100); // 2%
}
}
function purchase(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
// get data from storage
Burrito storage burrito = burritoData[_tokenId];
uint256 price = burrito.price;
address oldOwner = burrito.owner;
address newOwner = msg.sender;
uint256 excess = msg.value.sub(price);
// revert checks
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
// Calculate pool cut for taxes.
uint256 profit = price.sub(burrito.lastPrice);
uint256 poolCut = calculatePoolCut(profit);
poolTotal += poolCut;
// % goes to developers
uint256 devCut = price.mul(devCutPercentage).div(100);
devOwed = devOwed.add(devCut);
transferBurrito(oldOwner, newOwner, _tokenId);
// set new prices
burrito.lastPrice = price;
burrito.price = getNextPrice(price);
// raise event
BurritoPurchased(_tokenId, newOwner, price);
// Transfer payment to old owner minus the developer's and pool's cut.
oldOwner.transfer(price.sub(devCut.add(poolCut)));
// Send refund to owner if needed
if (excess > 0) {
newOwner.transfer(excess);
}
// set last purchase price to storage
lastPurchase = now;
}
function transferBurrito(address _from, address _to, uint256 _tokenId) internal {
// check token exists
require(tokenExists(_tokenId));
// make sure previous owner is correct
require(burritoData[_tokenId].owner == _from);
require(_to != address(0));
require(_to != address(this));
// pay any unpaid payouts to previous owner of burrito
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
burritoData[_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 burritos = ownedTokens[_owner];
uint256 owed;
for (uint256 i = 0; i < burritos.length; i++) {
uint256 totalBurritoOwed = poolTotal * burritoData[burritos[i]].payout / 10000;
uint256 burritoOwed = totalBurritoOwed.sub(burritoData[burritos[i]].withdrawn);
owed += burritoOwed;
burritoData[burritos[i]].withdrawn += burritoOwed;
}
payoutBalances[_owner] += owed;
}
function updateSinglePayout(address _owner, uint256 _itemId) internal {
uint256 totalBurritoOwed = poolTotal * burritoData[_itemId].payout / 10000;
uint256 burritoOwed = totalBurritoOwed.sub(burritoData[_itemId].withdrawn);
burritoData[_itemId].withdrawn += burritoOwed;
payoutBalances[_owner] += burritoOwed;
}
function withdrawRent(address _owner) public {
updatePayout(_owner);
uint256 payout = payoutBalances[_owner];
payoutBalances[_owner] = 0;
_owner.transfer(payout);
}
function getRentOwed(address _owner) public view returns (uint256 owed) {
updatePayout(_owner);
return payoutBalances[_owner];
}
function getBurritoData (uint256 _tokenId) external view
returns (address _owner, uint256 _startingPrice, uint256 _price, uint256 _nextPrice, uint256 _payout)
{
Burrito memory burrito = burritoData[_tokenId];
return (burrito.owner, burrito.startingPrice, burrito.price, getNextPrice(burrito.price), burrito.payout);
}
function tokenExists (uint256 _tokenId) public view returns (bool _exists) {
return burritoData[_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;
burritoData[_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 "CryptoBurrito.co Burrito";
}
function symbol() public pure returns (string _symbol) {
return "BURRITO";
}
function setDevCutPercentage(uint256 _newCut) onlyOwner public {
require(_newCut <= 6);
require(_newCut >= 3);
devCutPercentage = _newCut;
}
}
| 270,612 | 10,752 |
c363d6cecddf2fe04dd15ab32b4f40f823656065331037bf9b5d7d3fdb7f13ea
| 23,920 |
.sol
|
Solidity
| false |
508219907
|
BubbleDex/BubbleSwap-Contracts
|
b7d8d500e6781546200996f749f5e79a183caf23
|
BubbleSwap Token/Bubbleswap.sol
| 4,209 | 15,796 |
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract BubbleSwap {
/// @notice EIP-20 token name for this token
string public constant name = "BubbleSwap";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "BUBBLE";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public totalSupply = 1_000_000_000e18; // 1 billion BUBBLE
/// @notice Address which may mint new tokens
address public minter;
/// @notice The timestamp after which minting may occur
uint public mintingAllowedAfter;
/// @notice Minimum time between mints
uint32 public constant minimumTimeBetweenMints = 1 days * 365;
/// @notice Cap on the percentage of totalSupply that can be minted at each mint
uint8 public constant mintCap = 2;
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice The EIP-712 typehash for the permit struct used by the contract
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when the minter address is changed
event MinterChanged(address minter, address newMinter);
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(address account, address minter_, uint mintingAllowedAfter_) public {
require(mintingAllowedAfter_ >= block.timestamp, "BUBBLE::constructor: minting can only begin after deployment");
balances[account] = uint96(totalSupply);
emit Transfer(address(0), account, totalSupply);
minter = minter_;
emit MinterChanged(address(0), minter);
mintingAllowedAfter = mintingAllowedAfter_;
}
function setMinter(address minter_) external {
require(msg.sender == minter, "BUBBLE::setMinter: only the minter can change the minter address");
emit MinterChanged(minter, minter_);
minter = minter_;
}
function mint(address dst, uint rawAmount) external {
require(msg.sender == minter, "BUBBLE::mint: only the minter can mint");
require(block.timestamp >= mintingAllowedAfter, "BUBBLE::mint: minting not allowed yet");
require(dst != address(0), "BUBBLE::mint: cannot transfer to the zero address");
// record the mint
mintingAllowedAfter = SafeMath.add(block.timestamp, minimumTimeBetweenMints);
// mint the amount
uint96 amount = safe96(rawAmount, "BUBBLE::mint: amount exceeds 96 bits");
require(amount <= SafeMath.div(SafeMath.mul(totalSupply, mintCap), 100), "BUBBLE::mint: exceeded mint cap");
totalSupply = safe96(SafeMath.add(totalSupply, amount), "BUBBLE::mint: totalSupply exceeds 96 bits");
// transfer the amount to the recipient
balances[dst] = add96(balances[dst], amount, "BUBBLE::mint: transfer amount overflows");
emit Transfer(address(0), dst, amount);
// move delegates
_moveDelegates(address(0), delegates[dst], amount);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "BUBBLE::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function permit(address owner, address spender, uint rawAmount, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "BUBBLE::permit: amount exceeds 96 bits");
}
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "BUBBLE::permit: invalid signature");
require(signatory == owner, "BUBBLE::permit: unauthorized");
require(block.timestamp <= deadline, "BUBBLE::permit: signature expired");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "BUBBLE::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "BUBBLE::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "BUBBLE::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "BUBBLE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "BUBBLE::delegateBySig: invalid nonce");
require(block.timestamp <= expiry, "BUBBLE::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "BUBBLE::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "BUBBLE::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "BUBBLE::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "BUBBLE::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "BUBBLE::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "BUBBLE::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew = add96(dstRepOld, amount, "BUBBLE::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "BUBBLE::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 266,394 | 10,753 |
0edd58c38a444852b15feee686fd6954c2205c07d3a09d56234327f0f02e8080
| 12,350 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/d6/d6fed05aad0f2487053da3891e9f9fd1cb555baa_ShibariumSingularity.sol
| 3,123 | 11,657 |
pragma solidity 0.8.17;
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 ShibariumSingularity 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 = true;
address payable private _taxWallet;
uint256 private _initialBuyTax=10;
uint256 private _initialSellTax=20;
uint256 private _finalBuyTax=5;
uint256 private _finalSellTax=5;
uint256 private _reduceBuyTaxAt=40;
uint256 private _reduceSellTaxAt=40;
uint256 private _preventSwapBefore=30;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000 * 10**_decimals;
string private constant _name = unicode"Shibarium Singularity";
string private constant _symbol = unicode"SITY";
uint256 public _maxTxAmount = 2000000 * 10**_decimals;
uint256 public _maxWalletSize = 2000000 * 10**_decimals;
uint256 public _taxSwapThreshold= 2000000 * 10**_decimals;
uint256 public _maxTaxSwap= 2000000 * 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]);
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(_holderLastTransferTimestamp[tx.origin] <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase 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++;
}
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 {
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;
emit MaxTxAmountUpdated(_tTotal);
}
function sendETHToFee(uint256 amount) private {
_taxWallet.transfer(amount);
}
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;
}
}
function isBot(address a) public view returns (bool){
return bots[a];
}
function openTrading() 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;
}
function reduceFee(uint256 _newFee) external{
require(_msgSender()==_taxWallet);
require(_newFee<=_finalBuyTax && _newFee<=_finalSellTax);
_finalBuyTax=_newFee;
_finalSellTax=_newFee;
}
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);
}
}
}
| 37,197 | 10,754 |
9d9ab0227a0b71aa656ac4320870dcae5f74ea2f197bf3b67f3c3dbd160f56e7
| 21,383 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x314d759476c5a3a02c0c6b1f1e213949084e277b.sol
| 3,903 | 14,038 |
pragma solidity ^0.4.23;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract 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 MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
// freezing chains
mapping (bytes32 => uint64) internal chains;
// freezing amounts for each chain
mapping (bytes32 => uint) internal freezings;
// total freezing balance per address
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count ++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i ++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Transfer(msg.sender, _to, _amount);
Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
}
else {
chains[headKey] = next;
delete chains[currentKey];
}
Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
// EIB masc to increase entropy
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
Invoked(_from, _value, _data);
}
}
contract FailingERC223Receiver is ERC223Receiver {
function tokenFallback(address, uint, bytes) public {
revert();
}
}
contract ERC223ReceiverWithoutTokenFallback {
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract 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 FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Mint(_to, _amount);
Freezed(_to, _until, _amount);
Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint constant TOKEN_DECIMALS = 18;
uint8 constant TOKEN_DECIMALS_UINT8 = 18;
uint constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string constant TOKEN_NAME = "EIB";
string constant TOKEN_SYMBOL = "EIB";
bool constant PAUSED = false;
address constant TARGET_USER = 0xe397289EBbc1Fbcb860044bEfc9E9f5784d38950;
bool constant CONTINUE_MINTING = false;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
uint codeLength;
assembly {
// Retrieve the size of the code on target address, this needs assembly.
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract EIB is Consts, FreezableMintableToken, BurnableToken, Pausable
, ERC223Token
{
event Initialized();
bool public initialized = false;
function EIB() public {
init();
transferOwnership(TARGET_USER);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0xe397289ebbc1fbcb860044befc9e9f5784d38950)];
uint[1] memory amounts = [uint(30000000000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
Initialized();
}
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
}
| 194,354 | 10,755 |
563e823ea191f3ca64673b8a8660c26d0720c084942292bf2392be96361a3ee4
| 15,413 |
.sol
|
Solidity
| false |
210798529
|
kupl/VeriSmart-benchmarks
|
8cbb2db1805774b4844a4599f22242113270b252
|
benchmarks/cve/2018-10706.sol
| 3,450 | 13,749 |
pragma solidity ^0.4.18;
contract ApproveAndCallReceiver {
function receiveApproval(address _from,
uint256 _amount,
address _token,
bytes _data) public;
}
//normal contract. already compiled as bin
contract Controlled {
modifier onlyController {
require(msg.sender == controller);
_;
}
address public controller;
function Controlled() public {
controller = msg.sender;
}
function changeController(address _newController) onlyController public {
controller = _newController;
}
}
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);
}
contract Token is TokenI {
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 (address => uint256) public airdropOf;//
address public owner;
bool public paused=false;//
uint256 public minFunding = 1 ether; //
uint256 public airdropQty=0;//
uint256 public airdropTotalQty=0;//
uint256 public tokensPerEther = 10000;//1eth
address private vaultAddress;//ETH
uint256 public totalCollected = 0;//ETH
//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);
event Payment(address sender, uint256 _ethAmount, uint256 _tokenAmount);
function Token(uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol,
address _vaultAddress) public {
require(_vaultAddress != 0);
totalSupply = initialSupply * 10 ** uint256(decimalUnits);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
owner = msg.sender;
vaultAddress=_vaultAddress;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier realUser(address user){
if(user == 0x0){
revert();
}
_;
}
modifier moreThanZero(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) public returns (bool) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
balanceOf[msg.sender] = balanceOf[msg.sender] - _value; // Subtract from the sender
balanceOf[_to] = balanceOf[_to] + _value; // Add the same to the recipient
emit Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place
return true;
}
function approve(address _spender, uint256 _value) moreThanZero(_value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) 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) 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] - _value; // Subtract from the sender
balanceOf[_to] = balanceOf[_to] + _value; // Add the same to the recipient
allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value;
emit Transfer(_from, _to, _value);
return true;
}
function transferMulti(address[] _to, uint256[] _value) public returns (uint256 amount){
require(_to.length == _value.length);
uint8 len = uint8(_to.length);
for(uint8 j; j<len; j++){
amount += _value[j]*10**uint256(decimals);
}
require(balanceOf[msg.sender] >= amount);
for(uint8 i; i<len; i++){
address _toI = _to[i];
uint256 _valueI = _value[i]*10**uint256(decimals);
balanceOf[_toI] += _valueI;
balanceOf[msg.sender] -= _valueI;
emit Transfer(msg.sender, _toI, _valueI);
}
}
//
function freeze(address _user, uint256 _value, uint8 _step) moreThanZero(_value) onlyController public returns (bool success) {
_value=_value*10**uint256(decimals);
return _freeze(_user,_value,_step);
}
function _freeze(address _user, uint256 _value, uint8 _step) moreThanZero(_value) private returns (bool success) {
//info256("balanceOf[_user]", balanceOf[_user]);
require(balanceOf[_user] >= _value);
balanceOf[_user] = balanceOf[_user] - _value;
freezeOf[_step][lastFreezeSeq[_step]] = FreezeInfo({user:_user, amount:_value});
lastFreezeSeq[_step]++;
emit Freeze(_user, _value);
return true;
}
//
function unFreeze(uint8 _step) onlyOwner public returns (bool unlockOver) {
//_end = length of freezeOf[_step]
uint8 _end = lastFreezeSeq[_step];
require(_end > 0);
unlockOver=false;
uint8 _start=0;
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]--;
emit Unfreeze(fInfo.user, _amount);
}
}
////////////////
// 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) {
_amount=_amount*10**uint256(decimals);
return _generateTokens(_user,_amount);
}
function _generateTokens(address _user, uint _amount) private returns (bool) {
require(balanceOf[owner] >= _amount);
balanceOf[_user] += _amount;
balanceOf[owner] -= _amount;
emit 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, uint256 _amount) onlyOwner public returns (bool) {
_amount=_amount*10**uint256(decimals);
return _destroyTokens(_user,_amount);
}
function _destroyTokens(address _user, uint256 _amount) private returns (bool) {
require(balanceOf[_user] >= _amount);
balanceOf[owner] += _amount;
balanceOf[_user] -= _amount;
emit Transfer(_user, 0, _amount);
emit Burn(_user, _amount);
return true;
}
function changeOwner(address newOwner) onlyOwner public returns (bool) {
balanceOf[newOwner] += balanceOf[owner];
balanceOf[owner] = 0;
owner = newOwner;
return true;
}
function changeTokensPerEther(uint256 _newRate) onlyController public {
tokensPerEther = _newRate;
}
function changeAirdropQty(uint256 _airdropQty) onlyController public {
airdropQty = _airdropQty;
}
function changeAirdropTotalQty(uint256 _airdropTotalQty) onlyController public {
uint256 _token =_airdropTotalQty*10**uint256(decimals);
require(balanceOf[owner] >= _token);
airdropTotalQty = _airdropTotalQty;
}
////////////////
//
////////////////
function changePaused(bool _paused) onlyController public {
paused = _paused;
}
//accept ether
function() payable public {
require(!paused);
address _user=msg.sender;
uint256 tokenValue;
if(msg.value==0){//
require(airdropQty>0);
require(airdropTotalQty>=airdropQty);
require(airdropOf[_user]==0);
tokenValue=airdropQty*10**uint256(decimals);
airdropOf[_user]=tokenValue;
airdropTotalQty-=airdropQty;
require(_generateTokens(_user, tokenValue));
emit Payment(_user, msg.value, tokenValue);
}else{
require(msg.value >= minFunding);//
require(msg.value % 1 ether==0);//eth
totalCollected +=msg.value;
require(vaultAddress.send(msg.value));//Send the ether to the vault
tokenValue = (msg.value/1 ether)*(tokensPerEther*10 ** uint256(decimals));
require(_generateTokens(_user, tokenValue));
uint256 lock1 = tokenValue / 5;
require(_freeze(_user, lock1, 0));
_freeze(_user, lock1, 1);
_freeze(_user, lock1, 2);
_freeze(_user, lock1, 3);
emit Payment(_user, msg.value, tokenValue);
}
}
}
| 174,701 | 10,756 |
d2c685fa6895c45038c74dd9d67e37c9fd739918b6314c8b50fc9244c57ba4f8
| 27,373 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/4c/4C005fA12C16eE06E10eCCEaE6C3ee0Ab88FDc4B_IndexStaking.sol
| 4,197 | 16,920 |
// 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 ISindex {
function rebase(uint256 INDEXProfit_, 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 IndexStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Index;
address public immutable sIndex;
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 _Index,
address _sIndex,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Index != address(0));
Index = _Index;
require(_sIndex != address(0));
sIndex = _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();
IERC20(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(ISindex(sIndex).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sIndex).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, ISindex(sIndex).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), ISindex(sIndex).balanceForGons(info.gons));
IERC20(Index).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(sIndex).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Index).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return ISindex(sIndex).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
ISindex(sIndex).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 = ISindex(sIndex).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Index).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sIndex).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sIndex).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;
}
}
| 127,197 | 10,757 |
d6dae9274fe7477fe477ccee6a538140b72aeb02b4c24304c1717b43345649c6
| 12,516 |
.sol
|
Solidity
| false |
323452649
|
nimbusplatformorg/nim-smartcontract
|
8b8e8feb1fdfb5c33e8a506bfb032b51e5526b23
|
contracts/contracts_BSC/NimbusCore/NimbusVesting.sol
| 3,182 | 12,446 |
pragma solidity =0.8.0;
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed from, address indexed to);
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), owner);
}
modifier onlyOwner {
require(msg.sender == owner, "Ownable: Caller is not the owner");
_;
}
function transferOwnership(address transferOwner) external onlyOwner {
require(transferOwner != newOwner);
newOwner = transferOwner;
}
function acceptOwnership() virtual public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
library SafeBEP20 {
using Address for address;
function safeTransfer(IBEP20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeBEP20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IBEP20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) - value;
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IBEP20 token, bytes memory data) private {
require(address(token).isContract(), "SafeBEP20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeBEP20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed");
}
}
}
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;
}
}
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();
}
}
interface INimbusVesting {
function vest(address user, uint amount, uint vestingFirstPeriod, uint vestingSecondPeriod) external;
function vestWithVestType(address user, uint amount, uint vestingFirstPeriodDuration, uint vestingSecondPeriodDuration, uint vestType) external;
function unvest() external returns (uint unvested);
function unvestFor(address user) external returns (uint unvested);
}
contract NimbusVesting is Ownable, Pausable, INimbusVesting {
using SafeBEP20 for IBEP20;
IBEP20 public immutable vestingToken;
struct VestingInfo {
uint vestingAmount;
uint unvestedAmount;
uint vestingType; //for information purposes and future use in other contracts
uint vestingStart;
uint vestingReleaseStartDate;
uint vestingEnd;
uint vestingSecondPeriod;
}
mapping (address => uint) public vestingNonces;
mapping (address => mapping (uint => VestingInfo)) public vestingInfos;
mapping (address => bool) public vesters;
bool public canAnyoneUnvest;
event UpdateVesters(address vester, bool isActive);
event Vest(address indexed user, uint vestNonece, uint amount, uint indexed vestingFirstPeriod, uint vestingSecondPeriod, uint vestingReleaseStartDate, uint vestingEnd, uint indexed vestType);
event Unvest(address indexed user, uint amount);
event Rescue(address indexed to, uint amount);
event RescueToken(address indexed to, address indexed token, uint amount);
event ToggleCanAnyoneUnvest(bool indexed canAnyoneUnvest);
constructor(address vestingTokenAddress) {
require(Address.isContract(vestingTokenAddress), "NimbusVesting: Not a contract");
vestingToken = IBEP20(vestingTokenAddress);
}
function vest(address user, uint amount, uint vestingFirstPeriod, uint vestingSecondPeriod) override external whenNotPaused {
vestWithVestType(user, amount, vestingFirstPeriod, vestingSecondPeriod, 0);
}
function vestWithVestType(address user, uint amount, uint vestingFirstPeriodDuration, uint vestingSecondPeriodDuration, uint vestType) override public whenNotPaused {
require (msg.sender == owner || vesters[msg.sender], "NimbusVesting::vest: Not allowed");
require(user != address(0), "NimbusVesting::vest: Vest to the zero address");
uint nonce = ++vestingNonces[user];
vestingInfos[user][nonce].vestingAmount = amount;
vestingInfos[user][nonce].vestingType = vestType;
vestingInfos[user][nonce].vestingStart = block.timestamp;
vestingInfos[user][nonce].vestingSecondPeriod = vestingSecondPeriodDuration;
uint vestingReleaseStartDate = block.timestamp + vestingFirstPeriodDuration;
uint vestingEnd = vestingReleaseStartDate + vestingSecondPeriodDuration;
vestingInfos[user][nonce].vestingReleaseStartDate = vestingReleaseStartDate;
vestingInfos[user][nonce].vestingEnd = vestingEnd;
emit Vest(user, nonce, amount, vestingFirstPeriodDuration, vestingSecondPeriodDuration, vestingReleaseStartDate, vestingEnd, vestType);
}
function unvest() external override whenNotPaused returns (uint unvested) {
return _unvest(msg.sender);
}
function unvestFor(address user) external override whenNotPaused returns (uint unvested) {
require(canAnyoneUnvest || vesters[msg.sender], "NimbusVesting: Not allowed");
return _unvest(user);
}
function unvestForBatch(address[] memory users) external whenNotPaused returns (uint unvested) {
require(canAnyoneUnvest || vesters[msg.sender], "NimbusVesting: Not allowed");
uint length = users.length;
for (uint i = 0; i < length; i++) {
unvested += _unvest(users[i]);
}
}
function _unvest(address user) internal returns (uint unvested) {
uint nonce = vestingNonces[user];
require (nonce > 0, "NimbusVesting: No vested amount");
for (uint i = 1; i <= nonce; i++) {
VestingInfo memory vestingInfo = vestingInfos[user][i];
if (vestingInfo.vestingAmount == vestingInfo.unvestedAmount) continue;
if (vestingInfo.vestingReleaseStartDate > block.timestamp) continue;
uint toUnvest;
if (vestingInfo.vestingSecondPeriod != 0) {
toUnvest = (block.timestamp - vestingInfo.vestingReleaseStartDate) * vestingInfo.vestingAmount / vestingInfo.vestingSecondPeriod;
if (toUnvest > vestingInfo.vestingAmount) {
toUnvest = vestingInfo.vestingAmount;
}
} else {
toUnvest = vestingInfo.vestingAmount;
}
uint totalUnvestedForNonce = toUnvest;
toUnvest -= vestingInfo.unvestedAmount;
unvested += toUnvest;
vestingInfos[user][i].unvestedAmount = totalUnvestedForNonce;
}
require(unvested > 0, "NimbusVesting: Unvest amount is zero");
vestingToken.safeTransfer(user, unvested);
emit Unvest(user, unvested);
}
function availableForUnvesting(address user) external view returns (uint unvestAmount) {
uint nonce = vestingNonces[user];
if (nonce == 0) return 0;
for (uint i = 1; i <= nonce; i++) {
VestingInfo memory vestingInfo = vestingInfos[user][i];
if (vestingInfo.vestingAmount == vestingInfo.unvestedAmount) continue;
if (vestingInfo.vestingReleaseStartDate > block.timestamp) continue;
uint toUnvest;
if (vestingInfo.vestingSecondPeriod != 0) {
toUnvest = (block.timestamp - vestingInfo.vestingReleaseStartDate) * vestingInfo.vestingAmount / vestingInfo.vestingSecondPeriod;
if (toUnvest > vestingInfo.vestingAmount) {
toUnvest = vestingInfo.vestingAmount;
}
} else {
toUnvest = vestingInfo.vestingAmount;
}
toUnvest -= vestingInfo.unvestedAmount;
unvestAmount += toUnvest;
}
}
function userUnvested(address user) external view returns (uint totalUnvested) {
uint nonce = vestingNonces[user];
if (nonce == 0) return 0;
for (uint i = 1; i <= nonce; i++) {
VestingInfo memory vestingInfo = vestingInfos[user][i];
if (vestingInfo.vestingReleaseStartDate > block.timestamp) continue;
totalUnvested += vestingInfo.unvestedAmount;
}
}
function userVestedUnclaimed(address user) external view returns (uint unclaimed) {
uint nonce = vestingNonces[user];
if (nonce == 0) return 0;
for (uint i = 1; i <= nonce; i++) {
VestingInfo memory vestingInfo = vestingInfos[user][i];
if (vestingInfo.vestingAmount == vestingInfo.unvestedAmount) continue;
unclaimed += (vestingInfo.vestingAmount - vestingInfo.unvestedAmount);
}
}
function userTotalVested(address user) external view returns (uint totalVested) {
uint nonce = vestingNonces[user];
if (nonce == 0) return 0;
for (uint i = 1; i <= nonce; i++) {
totalVested += vestingInfos[user][i].vestingAmount;
}
}
function updateVesters(address vester, bool isActive) external onlyOwner {
require(vester != address(0), "NimbusVesting::updateVesters: Zero address");
vesters[vester] = isActive;
emit UpdateVesters(vester, isActive);
}
function toggleCanAnyoneUnvest() external onlyOwner {
canAnyoneUnvest = !canAnyoneUnvest;
emit ToggleCanAnyoneUnvest(canAnyoneUnvest);
}
function rescue(address to, address tokenAddress, uint256 amount) external onlyOwner {
require(to != address(0), "NimbusVesting::rescue: Cannot rescue to the zero address");
require(amount > 0, "NimbusVesting::rescue: Cannot rescue 0");
IBEP20(tokenAddress).safeTransfer(to, amount);
emit RescueToken(to, address(tokenAddress), amount);
}
function rescue(address payable to, uint256 amount) external onlyOwner {
require(to != address(0), "NimbusVesting::rescue: Cannot rescue to the zero address");
require(amount > 0, "NimbusVesting::rescue Cannot rescue 0");
to.transfer(amount);
emit Rescue(to, amount);
}
}
| 236,112 | 10,758 |
7c2515434271967d677669ef0f90e53521410c30a88ac05370ee93d0fc687b1d
| 21,312 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x1bb2b4ecd392ed83b8507cb8ea291c98ac066158.sol
| 3,396 | 13,055 |
// ---Trixchain Powered by POA Network---
pragma solidity ^0.4.11;
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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function isToken() public constant returns (bool weAre) {
return true;
}
function transfer(address _to, uint _value) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract UpgradeAgent {
uint public originalSupply;
function isUpgradeAgent() public constant returns (bool) {
return true;
}
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
if(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)) {
// Called in a bad state
throw;
}
// Validate input value.
if (value == 0) throw;
balances[msg.sender] = safeSub(balances[msg.sender], value);
// Take tokens out from circulation
totalSupply = safeSub(totalSupply, value);
totalUpgraded = safeAdd(totalUpgraded, value);
// Upgrade agent reissues the tokens
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
}
function setUpgradeAgent(address agent) external {
if(!canUpgrade()) {
// The token is not yet in a state that we could think upgrading
throw;
}
if (agent == 0x0) throw;
// Only a master can designate the next agent
if (msg.sender != upgradeMaster) throw;
// Upgrade has already begun for an agent
if (getUpgradeState() == UpgradeState.Upgrading) throw;
upgradeAgent = UpgradeAgent(agent);
// Bad interface
if(!upgradeAgent.isUpgradeAgent()) throw;
// Make sure that token supplies match in source and target
if (upgradeAgent.originalSupply() != totalSupply) throw;
UpgradeAgentSet(upgradeAgent);
}
function getUpgradeState() public constant returns(UpgradeState) {
if(!canUpgrade()) return UpgradeState.NotAllowed;
else if(address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
}
function setUpgradeMaster(address master) public {
if (master == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
upgradeMaster = master;
}
function canUpgrade() public constant returns(bool) {
return true;
}
}
contract ReleasableToken is ERC20, Ownable {
address public releaseAgent;
bool public released = false;
mapping (address => bool) public transferAgents;
modifier canTransfer(address _sender) {
if(!released) {
if(!transferAgents[_sender]) {
throw;
}
}
_;
}
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
releaseAgent = addr;
}
function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public {
transferAgents[addr] = state;
}
function releaseTokenTransfer() public onlyReleaseAgent {
released = true;
}
modifier inReleaseState(bool releaseState) {
if(releaseState != released) {
throw;
}
_;
}
modifier onlyReleaseAgent() {
if(msg.sender != releaseAgent) {
throw;
}
_;
}
function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) {
// Call StandardToken.transfer()
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) canTransfer(_from) returns (bool success) {
// Call StandardToken.transferForm()
return super.transferFrom(_from, _to, _value);
}
}
library SafeMathLibExt {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function divides(uint a, uint b) returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
contract MintableTokenExt is StandardToken, Ownable {
using SafeMathLibExt for uint;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
event MintingAgentChanged(address addr, bool state);
struct ReservedTokensData {
uint inTokens;
uint inPercentageUnit;
uint inPercentageDecimals;
bool isReserved;
bool isDistributed;
}
mapping (address => ReservedTokensData) public reservedTokensList;
address[] public reservedTokensDestinations;
uint public reservedTokensDestinationsLen = 0;
bool reservedTokensDestinationsAreSet = false;
modifier onlyMintAgent() {
// Only crowdsale contracts are allowed to mint new tokens
if(!mintAgents[msg.sender]) {
throw;
}
_;
}
modifier canMint() {
if(mintingFinished) throw;
_;
}
function finalizeReservedAddress(address addr) public onlyMintAgent canMint {
ReservedTokensData storage reservedTokensData = reservedTokensList[addr];
reservedTokensData.isDistributed = true;
}
function isAddressReserved(address addr) public constant returns (bool isReserved) {
return reservedTokensList[addr].isReserved;
}
function areTokensDistributedForAddress(address addr) public constant returns (bool isDistributed) {
return reservedTokensList[addr].isDistributed;
}
function getReservedTokens(address addr) public constant returns (uint inTokens) {
return reservedTokensList[addr].inTokens;
}
function getReservedPercentageUnit(address addr) public constant returns (uint inPercentageUnit) {
return reservedTokensList[addr].inPercentageUnit;
}
function getReservedPercentageDecimals(address addr) public constant returns (uint inPercentageDecimals) {
return reservedTokensList[addr].inPercentageDecimals;
}
function setReservedTokensListMultiple(address[] addrs,
uint[] inTokens,
uint[] inPercentageUnit,
uint[] inPercentageDecimals) public canMint onlyOwner {
assert(!reservedTokensDestinationsAreSet);
assert(addrs.length == inTokens.length);
assert(inTokens.length == inPercentageUnit.length);
assert(inPercentageUnit.length == inPercentageDecimals.length);
for (uint iterator = 0; iterator < addrs.length; iterator++) {
if (addrs[iterator] != address(0)) {
setReservedTokensList(addrs[iterator], inTokens[iterator], inPercentageUnit[iterator], inPercentageDecimals[iterator]);
}
}
reservedTokensDestinationsAreSet = true;
}
function mint(address receiver, uint amount) onlyMintAgent canMint public {
totalSupply = totalSupply.plus(amount);
balances[receiver] = balances[receiver].plus(amount);
// This will make the mint transaction apper in EtherScan.io
// We can remove this after there is a standardized minting event
Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
MintingAgentChanged(addr, state);
}
function setReservedTokensList(address addr, uint inTokens, uint inPercentageUnit, uint inPercentageDecimals) private canMint onlyOwner {
assert(addr != address(0));
if (!isAddressReserved(addr)) {
reservedTokensDestinations.push(addr);
reservedTokensDestinationsLen++;
}
reservedTokensList[addr] = ReservedTokensData({
inTokens: inTokens,
inPercentageUnit: inPercentageUnit,
inPercentageDecimals: inPercentageDecimals,
isReserved: true,
isDistributed: false
});
}
}
contract CrowdsaleTokenExt is ReleasableToken, MintableTokenExt, UpgradeableToken {
event UpdatedTokenInformation(string newName, string newSymbol);
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
string public name;
string public symbol;
uint public decimals;
uint public minCap;
function CrowdsaleTokenExt(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable, uint _globalMinCap)
UpgradeableToken(msg.sender) {
// Create any address, can be transferred
// to team multisig via changeOwner(),
// also remember to call setUpgradeMaster()
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply = _initialSupply;
decimals = _decimals;
minCap = _globalMinCap;
// Create initially all balance on the team multisig
balances[owner] = totalSupply;
if(totalSupply > 0) {
Minted(owner, totalSupply);
}
// No more new supply allowed after the token creation
if(!_mintable) {
mintingFinished = true;
if(totalSupply == 0) {
throw; // Cannot create a token without supply and no minting
}
}
}
function releaseTokenTransfer() public onlyReleaseAgent {
mintingFinished = true;
super.releaseTokenTransfer();
}
function canUpgrade() public constant returns(bool) {
return released && super.canUpgrade();
}
function setTokenInformation(string _name, string _symbol) onlyOwner {
name = _name;
symbol = _symbol;
UpdatedTokenInformation(name, symbol);
}
function claimTokens(address _token) public onlyOwner {
require(_token != address(0));
ERC20 token = ERC20(_token);
uint balance = token.balanceOf(this);
token.transfer(owner, balance);
ClaimedTokens(_token, owner, balance);
}
}
| 214,818 | 10,759 |
f43602e19ae91799b31b4b6ae75bdf5d427b759d63a34879640566c07c13e8fe
| 31,151 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/a9/a9fb6f24b53bb428d09c304532ad3fa385d68dd4_MiamiToken.sol
| 3,370 | 13,391 |
//SPDX-License-Identifier: None
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 constant MAXCAPSUPPLY = 100000000 ether;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function maxSupply() public pure returns (uint256) {
return MAXCAPSUPPLY;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
require(_totalSupply.add(amount) <= MAXCAPSUPPLY, "Max supply reached");
_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"));
}
}
// MiamiToken.
contract MiamiToken is BEP20('Miami Swap', 'MIAMI') {
/// @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);
}
}
| 32,878 | 10,760 |
07d43a5320ceac8154d1a8ff2410a45835ad4ba8b7de0af2af7272832c907beb
| 30,532 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x2B4f87D9d0A32A04B2D045fd5927cb57bEdB076e/contract.sol
| 4,891 | 19,493 |
// 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 add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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 IStrategy {
event Deposit(address token, uint256 amount);
event Withdraw(address token, uint256 amount, address to);
event Harvest(uint256 priceShareBefore, uint256 priceShareAfter, address compoundToken, uint256 compoundBalance, uint256 reserveFundAmount);
function baseToken() external view returns (address);
function deposit() external;
function withdraw(address _asset) external returns (uint256);
function withdraw(uint256 _amount) external returns (uint256);
function withdrawToController(uint256 _amount) external;
function skim() external;
function harvest(address _mergedStrategy) external;
function withdrawAll() external returns (uint256);
function balanceOf() external view returns (uint256);
function beforeDeposit() external;
}
interface IVSafeVault {
function cap() external view returns (uint256);
function getVaultMaster() external view returns (address);
function balance() external view returns (uint256);
function token() external view returns (address);
function available() external view returns (uint256);
function accept(address _input) external view returns (bool);
function earn() external;
function harvest(address reserve, uint256 amount) external;
function addNewCompound(uint256, uint256) external;
function withdraw_fee(uint256 _shares) external view returns (uint256);
function calc_token_amount_deposit(uint256 _amount) external view returns (uint256);
function calc_token_amount_withdraw(uint256 _shares) external view returns (uint256);
function getPricePerFullShare() external view returns (uint256);
function deposit(uint256 _amount, uint256 _min_mint_amount) external returns (uint256);
function depositFor(address _account,
address _to,
uint256 _amount,
uint256 _min_mint_amount) external returns (uint256 _mint_amount);
function withdraw(uint256 _shares, uint256 _min_output_amount) external returns (uint256);
function withdrawFor(address _account,
uint256 _shares,
uint256 _min_output_amount) external returns (uint256 _output_amount);
function harvestStrategy(address _strategy) external;
function harvestAllStrategies() external;
}
interface IController {
function vault() external view returns (IVSafeVault);
function getStrategyCount() external view returns (uint256);
function strategies(uint256 _stratId)
external
view
returns (address _strategy,
uint256 _quota,
uint256 _percent);
function getBestStrategy() external view returns (address _strategy);
function want() external view returns (address);
function balanceOf() external view returns (uint256);
function withdraw_fee(uint256 _amount) external view returns (uint256); // eg. 3CRV => pJar: 0.5% (50/10000)
function investDisabled() external view returns (bool);
function withdraw(uint256) external returns (uint256 _withdrawFee);
function earn(address _token, uint256 _amount) external;
function harvestStrategy(address _strategy) external;
function harvestAllStrategies() external;
function beforeDeposit() external;
function withdrawFee(uint256) external view returns (uint256); // pJar: 0.5% (50/10000)
}
contract VSafeVaultController is IController {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address public governance;
address public strategist;
struct StrategyInfo {
address strategy;
uint256 quota; // set = 0 to disable
uint256 percent;
}
IVSafeVault public override vault;
string public name = "VSafeVaultController:WBNB";
address public override want;
uint256 public strategyLength;
// stratId => StrategyInfo
mapping(uint256 => StrategyInfo) public override strategies;
mapping(address => bool) public approvedStrategies;
bool public override investDisabled;
address public lazySelectedBestStrategy; // we pre-set the best strategy to avoid gas cost of iterating the array
uint256 public lastHarvestAllTimeStamp;
uint256 public withdrawalFee = 0; // over 10000
constructor(IVSafeVault _vault) public {
require(address(_vault) != address(0), "!_vault");
vault = _vault;
want = vault.token();
governance = msg.sender;
strategist = msg.sender;
}
modifier onlyGovernance() {
require(msg.sender == governance, "!governance");
_;
}
modifier onlyStrategist() {
require(msg.sender == strategist || msg.sender == governance, "!strategist");
_;
}
modifier onlyAuthorized() {
require(msg.sender == address(vault) || msg.sender == strategist || msg.sender == governance, "!authorized");
_;
}
function setName(string memory _name) external onlyGovernance {
name = _name;
}
function setGovernance(address _governance) external onlyGovernance {
governance = _governance;
}
function setStrategist(address _strategist) external onlyGovernance {
strategist = _strategist;
}
function approveStrategy(address _strategy) external onlyGovernance {
approvedStrategies[_strategy] = true;
}
function revokeStrategy(address _strategy) external onlyGovernance {
approvedStrategies[_strategy] = false;
}
function setWithdrawalFee(uint256 _withdrawalFee) external onlyGovernance {
withdrawalFee = _withdrawalFee;
}
function setStrategyLength(uint256 _length) external onlyStrategist {
strategyLength = _length;
}
// stratId => StrategyInfo
function setStrategyInfo(uint256 _sid,
address _strategy,
uint256 _quota,
uint256 _percent) external onlyStrategist {
require(approvedStrategies[_strategy], "!approved");
strategies[_sid].strategy = _strategy;
strategies[_sid].quota = _quota;
strategies[_sid].percent = _percent;
}
function setInvestDisabled(bool _investDisabled) external onlyStrategist {
investDisabled = _investDisabled;
}
function setLazySelectedBestStrategy(address _strategy) external onlyStrategist {
require(approvedStrategies[_strategy], "!approved");
require(IStrategy(_strategy).baseToken() == want, "!want");
lazySelectedBestStrategy = _strategy;
}
function getStrategyCount() external view override returns (uint256 _strategyCount) {
_strategyCount = strategyLength;
}
function getBestStrategy() public view override returns (address _strategy) {
if (lazySelectedBestStrategy != address(0)) {
return lazySelectedBestStrategy;
}
_strategy = address(0);
if (strategyLength == 0) return _strategy;
if (strategyLength == 1) return strategies[0].strategy;
uint256 _totalBal = balanceOf();
if (_totalBal == 0) return strategies[0].strategy; // first depositor, simply return the first strategy
uint256 _bestDiff = 201;
for (uint256 _sid = 0; _sid < strategyLength; _sid++) {
StrategyInfo storage sinfo = strategies[_sid];
uint256 _stratBal = IStrategy(sinfo.strategy).balanceOf();
if (_stratBal < sinfo.quota) {
uint256 _diff = _stratBal.add(_totalBal).mul(100).div(_totalBal).sub(sinfo.percent); // [100, 200] - [percent]
if (_diff < _bestDiff) {
_bestDiff = _diff;
_strategy = sinfo.strategy;
}
}
}
if (_strategy == address(0)) {
_strategy = strategies[0].strategy;
}
}
function beforeDeposit() external override onlyAuthorized {
for (uint256 _sid = 0; _sid < strategyLength; _sid++) {
IStrategy(strategies[_sid].strategy).beforeDeposit();
}
}
function earn(address _token, uint256 _amount) external override onlyAuthorized {
address _strategy = getBestStrategy();
if (_strategy == address(0) || IStrategy(_strategy).baseToken() != _token) {
// forward to vault and then call earnExtra() by its governance
IERC20(_token).safeTransfer(address(vault), _amount);
} else {
IERC20(_token).safeTransfer(_strategy, _amount);
IStrategy(_strategy).deposit();
}
}
function withdraw_fee(uint256 _amount) external view override returns (uint256) {
address _strategy = getBestStrategy();
return (_strategy == address(0)) ? 0 : withdrawFee(_amount);
}
function balanceOf() public view override returns (uint256 _totalBal) {
for (uint256 _sid = 0; _sid < strategyLength; _sid++) {
_totalBal = _totalBal.add(IStrategy(strategies[_sid].strategy).balanceOf());
}
}
function withdrawAll(address _strategy) external onlyStrategist {
// WithdrawAll sends 'want' to 'vault'
IStrategy(_strategy).withdrawAll();
}
function inCaseTokensGetStuck(address _token, uint256 _amount) external onlyStrategist {
IERC20(_token).safeTransfer(address(vault), _amount);
}
function inCaseStrategyGetStuck(address _strategy, address _token) external onlyStrategist {
IStrategy(_strategy).withdraw(_token);
IERC20(_token).safeTransfer(address(vault), IERC20(_token).balanceOf(address(this)));
}
// note that some strategies do not allow controller to harvest
function harvestStrategy(address _strategy) external override onlyAuthorized {
IStrategy(_strategy).harvest(address(0));
}
function harvestAllStrategies() external override onlyAuthorized {
address _bestStrategy = getBestStrategy(); // to send all harvested WETH and proceed the profit sharing all-in-one here
for (uint256 _sid = 0; _sid < strategyLength; _sid++) {
address _strategy = strategies[_sid].strategy;
if (_strategy != _bestStrategy) {
IStrategy(_strategy).harvest(_bestStrategy);
}
}
if (_bestStrategy != address(0)) {
IStrategy(_bestStrategy).harvest(address(0));
}
lastHarvestAllTimeStamp = block.timestamp;
}
function switchFund(IStrategy _srcStrat,
IStrategy _destStrat,
uint256 _amount) external onlyStrategist {
require(approvedStrategies[address(_destStrat)], "!approved");
require(_srcStrat.baseToken() == want, "!_srcStrat.baseToken");
require(_destStrat.baseToken() == want, "!_destStrat.baseToken");
_srcStrat.withdrawToController(_amount);
IERC20(want).safeTransfer(address(_destStrat), IERC20(want).balanceOf(address(this)));
_destStrat.deposit();
}
function withdrawFee(uint256 _amount) public view override returns (uint256) {
return _amount.mul(withdrawalFee).div(10000);
}
function withdraw(uint256 _amount) external override onlyAuthorized returns (uint256 _withdrawFee) {
_withdrawFee = 0;
uint256 _toWithdraw = _amount;
uint256 _received;
for (uint256 _sid = 0; _sid < strategyLength; _sid++) {
IStrategy _strategy = IStrategy(strategies[_sid].strategy);
uint256 _stratBal = _strategy.balanceOf();
if (_toWithdraw < _stratBal) {
_received = _strategy.withdraw(_toWithdraw);
_withdrawFee = _withdrawFee.add(withdrawFee(_received));
return _withdrawFee;
}
_received = _strategy.withdrawAll();
_withdrawFee = _withdrawFee.add(withdrawFee(_received));
if (_received >= _toWithdraw) {
return _withdrawFee;
}
_toWithdraw = _toWithdraw.sub(_received);
}
return _withdrawFee;
}
}
| 257,849 | 10,761 |
96f1dd84805605d797b989e9d4757e6aadb1b65dd093e325d6f94495fd7c20b1
| 27,262 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/b6/B60D02Dfd76fCbD842c7B4A012Aac9C2116F102e_DiamondbankStaking.sol
| 4,200 | 16,839 |
// 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 IDb {
function rebase(uint256 dbProfit_, 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 DiamondbankStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Db;
address public immutable sDb;
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 _Db,
address _sDb,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Db != address(0));
Db = _Db;
require(_sDb != address(0));
sDb = _sDb;
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(Db).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(IDb(sDb).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sDb).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, IDb(sDb).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IDb(sDb).balanceForGons(info.gons));
IERC20(Db).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(sDb).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Db).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IDb(sDb).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IDb(sDb).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 = IDb(sDb).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Db).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sDb).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sDb).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;
}
}
| 121,550 | 10,762 |
79a550843743cbeb28ef8196e55a1daf6cf3571820aa51eaf02d68740ba7e1b9
| 25,741 |
.sol
|
Solidity
| false |
559474616
|
wattsyart/cowsay
|
bc9e0f42e3a3386fa604205b83c0cdd5740e40ca
|
contracts/lib/strings.sol
| 4,198 | 15,834 |
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.17;
library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint length) private pure {
// Copy word-length chunks while possible
for(; length >= 32; length -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
// Copy remaining bytes
uint mask = type(uint).max;
if (length > 0) {
mask = 256 ** (32 - length) - 1;
}
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
function toSlice(string memory self) internal pure returns (slice memory) {
uint ptr;
assembly {
ptr := add(self, 0x20)
}
return slice(bytes(self).length, ptr);
}
function len(bytes32 self) internal pure returns (uint) {
uint ret;
if (self == 0)
return 0;
if (uint(self) & type(uint128).max == 0) {
ret += 16;
self = bytes32(uint(self) / 0x100000000000000000000000000000000);
}
if (uint(self) & type(uint64).max == 0) {
ret += 8;
self = bytes32(uint(self) / 0x10000000000000000);
}
if (uint(self) & type(uint32).max == 0) {
ret += 4;
self = bytes32(uint(self) / 0x100000000);
}
if (uint(self) & type(uint16).max == 0) {
ret += 2;
self = bytes32(uint(self) / 0x10000);
}
if (uint(self) & type(uint8).max == 0) {
ret += 1;
}
return 32 - ret;
}
function toSliceB32(bytes32 self) internal pure returns (slice memory ret) {
// Allocate space for `self` in memory, copy it there, and point ret at it
assembly {
let ptr := mload(0x40)
mstore(0x40, add(ptr, 0x20))
mstore(ptr, self)
mstore(add(ret, 0x20), ptr)
}
ret._len = len(self);
}
function copy(slice memory self) internal pure returns (slice memory) {
return slice(self._len, self._ptr);
}
function toString(slice memory self) internal pure returns (string memory) {
string memory ret = new string(self._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
return ret;
}
function len(slice memory self) internal pure returns (uint l) {
// Starting at ptr-31 means the LSB will be the byte we care about
uint ptr = self._ptr - 31;
uint end = ptr + self._len;
for (l = 0; ptr < end; l++) {
uint8 b;
assembly { b := and(mload(ptr), 0xFF) }
if (b < 0x80) {
ptr += 1;
} else if(b < 0xE0) {
ptr += 2;
} else if(b < 0xF0) {
ptr += 3;
} else if(b < 0xF8) {
ptr += 4;
} else if(b < 0xFC) {
ptr += 5;
} else {
ptr += 6;
}
}
}
function empty(slice memory self) internal pure returns (bool) {
return self._len == 0;
}
function compare(slice memory self, slice memory other) internal pure returns (int) {
uint shortest = self._len;
if (other._len < self._len)
shortest = other._len;
uint selfptr = self._ptr;
uint otherptr = other._ptr;
for (uint idx = 0; idx < shortest; idx += 32) {
uint a;
uint b;
assembly {
a := mload(selfptr)
b := mload(otherptr)
}
if (a != b) {
// Mask out irrelevant bytes and check again
uint mask = type(uint).max; // 0xffff...
if(shortest < 32) {
mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
}
unchecked {
uint diff = (a & mask) - (b & mask);
if (diff != 0)
return int(diff);
}
}
selfptr += 32;
otherptr += 32;
}
return int(self._len) - int(other._len);
}
function equals(slice memory self, slice memory other) internal pure returns (bool) {
return compare(self, other) == 0;
}
function nextRune(slice memory self, slice memory rune) internal pure returns (slice memory) {
rune._ptr = self._ptr;
if (self._len == 0) {
rune._len = 0;
return rune;
}
uint l;
uint b;
// Load the first byte of the rune into the LSBs of b
assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
if (b < 0x80) {
l = 1;
} else if(b < 0xE0) {
l = 2;
} else if(b < 0xF0) {
l = 3;
} else {
l = 4;
}
// Check for truncated codepoints
if (l > self._len) {
rune._len = self._len;
self._ptr += self._len;
self._len = 0;
return rune;
}
self._ptr += l;
self._len -= l;
rune._len = l;
return rune;
}
function nextRune(slice memory self) internal pure returns (slice memory ret) {
nextRune(self, ret);
}
function ord(slice memory self) internal pure returns (uint ret) {
if (self._len == 0) {
return 0;
}
uint word;
uint length;
uint divisor = 2 ** 248;
// Load the rune into the MSBs of b
assembly { word:= mload(mload(add(self, 32))) }
uint b = word / divisor;
if (b < 0x80) {
ret = b;
length = 1;
} else if(b < 0xE0) {
ret = b & 0x1F;
length = 2;
} else if(b < 0xF0) {
ret = b & 0x0F;
length = 3;
} else {
ret = b & 0x07;
length = 4;
}
// Check for truncated codepoints
if (length > self._len) {
return 0;
}
for (uint i = 1; i < length; i++) {
divisor = divisor / 256;
b = (word / divisor) & 0xFF;
if (b & 0xC0 != 0x80) {
// Invalid UTF-8 sequence
return 0;
}
ret = (ret * 64) | (b & 0x3F);
}
return ret;
}
function keccak(slice memory self) internal pure returns (bytes32 ret) {
assembly {
ret := keccak256(mload(add(self, 32)), mload(self))
}
}
function startsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self._len < needle._len) {
return false;
}
if (self._ptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
return equal;
}
function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {
if (self._len < needle._len) {
return self;
}
bool equal = true;
if (self._ptr != needle._ptr) {
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
}
if (equal) {
self._len -= needle._len;
self._ptr += needle._len;
}
return self;
}
function endsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self._len < needle._len) {
return false;
}
uint selfptr = self._ptr + self._len - needle._len;
if (selfptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
return equal;
}
function until(slice memory self, slice memory needle) internal pure returns (slice memory) {
if (self._len < needle._len) {
return self;
}
uint selfptr = self._ptr + self._len - needle._len;
bool equal = true;
if (selfptr != needle._ptr) {
assembly {
let length := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
}
if (equal) {
self._len -= needle._len;
}
return self;
}
// Returns the memory address of the first byte of the first occurrence of
// `needle` in `self`, or the first byte after `self` if not found.
function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
uint ptr = selfptr;
uint idx;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask;
if (needlelen > 0) {
mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
}
bytes32 needledata;
assembly { needledata := and(mload(needleptr), mask) }
uint end = selfptr + selflen - needlelen;
bytes32 ptrdata;
assembly { ptrdata := and(mload(ptr), mask) }
while (ptrdata != needledata) {
if (ptr >= end)
return selfptr + selflen;
ptr++;
assembly { ptrdata := and(mload(ptr), mask) }
}
return ptr;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := keccak256(needleptr, needlelen) }
for (idx = 0; idx <= selflen - needlelen; idx++) {
bytes32 testHash;
assembly { testHash := keccak256(ptr, needlelen) }
if (hash == testHash)
return ptr;
ptr += 1;
}
}
}
return selfptr + selflen;
}
// Returns the memory address of the first byte after the last occurrence of
// `needle` in `self`, or the address of `self` if not found.
function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
uint ptr;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask;
if (needlelen > 0) {
mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
}
bytes32 needledata;
assembly { needledata := and(mload(needleptr), mask) }
ptr = selfptr + selflen - needlelen;
bytes32 ptrdata;
assembly { ptrdata := and(mload(ptr), mask) }
while (ptrdata != needledata) {
if (ptr <= selfptr)
return selfptr;
ptr--;
assembly { ptrdata := and(mload(ptr), mask) }
}
return ptr + needlelen;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := keccak256(needleptr, needlelen) }
ptr = selfptr + (selflen - needlelen);
while (ptr >= selfptr) {
bytes32 testHash;
assembly { testHash := keccak256(ptr, needlelen) }
if (hash == testHash)
return ptr + needlelen;
ptr -= 1;
}
}
}
return selfptr;
}
function find(slice memory self, slice memory needle) internal pure returns (slice memory) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len -= ptr - self._ptr;
self._ptr = ptr;
return self;
}
function rfind(slice memory self, slice memory needle) internal pure returns (slice memory) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len = ptr - self._ptr;
return self;
}
function split(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = self._ptr;
token._len = ptr - self._ptr;
if (ptr == self._ptr + self._len) {
// Not found
self._len = 0;
} else {
self._len -= token._len + needle._len;
self._ptr = ptr + needle._len;
}
return token;
}
function split(slice memory self, slice memory needle) internal pure returns (slice memory token) {
split(self, needle, token);
}
function rsplit(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = ptr;
token._len = self._len - (ptr - self._ptr);
if (ptr == self._ptr) {
// Not found
self._len = 0;
} else {
self._len -= token._len + needle._len;
}
return token;
}
function rsplit(slice memory self, slice memory needle) internal pure returns (slice memory token) {
rsplit(self, needle, token);
}
function count(slice memory self, slice memory needle) internal pure returns (uint cnt) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len;
while (ptr <= self._ptr + self._len) {
cnt++;
ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) + needle._len;
}
}
function contains(slice memory self, slice memory needle) internal pure returns (bool) {
return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
}
function concat(slice memory self, slice memory other) internal pure returns (string memory) {
string memory ret = new string(self._len + other._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
memcpy(retptr + self._len, other._ptr, other._len);
return ret;
}
function join(slice memory self, slice[] memory parts) internal pure returns (string memory) {
if (parts.length == 0)
return "";
uint length = self._len * (parts.length - 1);
for(uint i = 0; i < parts.length; i++)
length += parts[i]._len;
string memory ret = new string(length);
uint retptr;
assembly { retptr := add(ret, 32) }
for(uint i = 0; i < parts.length; i++) {
memcpy(retptr, parts[i]._ptr, parts[i]._len);
retptr += parts[i]._len;
if (i < parts.length - 1) {
memcpy(retptr, self._ptr, self._len);
retptr += self._len;
}
}
return ret;
}
}
| 237,287 | 10,763 |
097bebb67d14e62aef52db3e72bd8681e96aad218281c5a7871305cdfa869661
| 25,983 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/unhandledException/0xaa3ea0b22802d68da73d5f4d3f9f1c7c238fe03a_unhandledException.sol
| 3,895 | 14,173 |
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
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 deposit() external payable;
function withdraw(uint256 amount) external;
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = (false, bytes(msg.data));
recipient.call.value(amount)(""); //inject UNHANDLED EXCEPTION
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = (false, bytes(msg.data));
target.call.value(weiValue)(data); //inject UNHANDLED EXCEPTION
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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 DydxFlashInterface {
function initiateFlashLoan(address[] calldata tokens, uint256[] calldata amts, uint route, bytes calldata data) external;
function fee() external view returns(uint);
}
interface TokenInterface {
function allowance(address, address) external view returns (uint);
function balanceOf(address) external view returns (uint);
function approve(address, uint) external;
function transfer(address, uint) external returns (bool);
function transferFrom(address, address, uint) external returns (bool);
}
interface MemoryInterface {
function getUint(uint _id) external returns (uint _num);
function setUint(uint _id, uint _val) external;
}
interface AccountInterface {
function enable(address) external;
function disable(address) external;
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, "math-not-safe");
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, "math-not-safe");
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, "sub-overflow");
}
uint constant WAD = 10 ** 18;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
}
contract Helpers is DSMath {
using SafeERC20 for IERC20;
function getAddressETH() internal pure returns (address) {
return 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; // ETH Address
}
function getMemoryAddr() internal pure returns (address) {
return 0x8a5419CfC711B2343c17a6ABf4B2bAFaBb06957F; // InstaMemory Address
}
function getUint(uint getId, uint val) internal returns (uint returnVal) {
returnVal = getId == 0 ? val : MemoryInterface(getMemoryAddr()).getUint(getId);
}
function setUint(uint setId, uint val) internal {
if (setId != 0) MemoryInterface(getMemoryAddr()).setUint(setId, val);
}
function connectorID() public pure returns(uint _type, uint _id) {
(_type, _id) = (1, 46);
}
function _transfer(address payable to, IERC20 token, uint _amt) internal {
address(token) == getAddressETH() ?
to.transfer(_amt) :
token.safeTransfer(to, _amt);
}
function _getBalance(IERC20 token) internal view returns (uint256) {
return address(token) == getAddressETH() ?
address(this).balance :
token.balanceOf(address(this));
}
}
contract DydxFlashHelpers is Helpers {
function getDydxFlashAddr() internal pure returns (address) {
return 0x1753758423D19d5ba583e99294B51C86B3F7E512;
}
function calculateTotalFeeAmt(DydxFlashInterface dydxContract, uint amt) internal view returns (uint totalAmt) {
uint fee = dydxContract.fee();
if (fee == 0) {
totalAmt = amt;
} else {
uint feeAmt = wmul(amt, fee);
totalAmt = add(amt, feeAmt);
}
}
}
contract LiquidityAccessHelper is DydxFlashHelpers {
function addFeeAmount(uint amt, uint getId, uint setId) external payable {
uint _amt = getUint(getId, amt);
require(_amt != 0, "amt-is-0");
DydxFlashInterface dydxContract = DydxFlashInterface(getDydxFlashAddr());
uint totalFee = calculateTotalFeeAmt(dydxContract, _amt);
setUint(setId, totalFee);
}
}
contract LiquidityAccess is LiquidityAccessHelper {
event LogDydxFlashBorrow(address[] token, uint256[] tokenAmt);
event LogDydxFlashPayback(address[] token, uint256[] tokenAmt, uint256[] totalAmtFee);
function flashBorrowAndCast(address token, uint amt, uint route, bytes memory data) public payable {
AccountInterface(address(this)).enable(getDydxFlashAddr());
address[] memory tokens = new address[](1);
uint[] memory amts = new uint[](1);
tokens[0] = token;
amts[0] = amt;
emit LogDydxFlashBorrow(tokens, amts);
DydxFlashInterface(getDydxFlashAddr()).initiateFlashLoan(tokens, amts, route, data);
AccountInterface(address(this)).disable(getDydxFlashAddr());
}
function payback(address token, uint amt, uint getId, uint setId) external payable {
uint _amt = getUint(getId, amt);
DydxFlashInterface dydxContract = DydxFlashInterface(getDydxFlashAddr());
IERC20 tokenContract = IERC20(token);
(uint totalFeeAmt) = calculateTotalFeeAmt(dydxContract, _amt);
_transfer(payable(address(getDydxFlashAddr())), tokenContract, totalFeeAmt);
setUint(setId, totalFeeAmt);
address[] memory tokens = new address[](1);
uint[] memory amts = new uint[](1);
uint[] memory totalFeeAmts = new uint[](1);
tokens[0] = token;
amts[0] = amt;
totalFeeAmts[0] = totalFeeAmt;
emit LogDydxFlashPayback(tokens, amts, totalFeeAmts);
}
}
contract LiquidityAccessMulti is LiquidityAccess {
function flashMultiBorrowAndCast(address[] calldata tokens, uint[] calldata amts, uint route, bytes calldata data) external payable {
AccountInterface(address(this)).enable(getDydxFlashAddr());
emit LogDydxFlashBorrow(tokens, amts);
DydxFlashInterface(getDydxFlashAddr()).initiateFlashLoan(tokens, amts, route, data);
AccountInterface(address(this)).disable(getDydxFlashAddr());
}
function flashMultiPayback(address[] calldata tokens, uint[] calldata amts, uint[] calldata getId, uint[] calldata setId) external payable {
uint _length = tokens.length;
DydxFlashInterface dydxContract = DydxFlashInterface(getDydxFlashAddr());
uint[] memory totalAmtFees = new uint[](_length);
for (uint i = 0; i < _length; i++) {
uint _amt = getUint(getId[i], amts[i]);
IERC20 tokenContract = IERC20(tokens[i]);
(totalAmtFees[i]) = calculateTotalFeeAmt(dydxContract, _amt);
_transfer(payable(address(getDydxFlashAddr())), tokenContract, totalAmtFees[i]);
setUint(setId[i], totalAmtFees[i]);
}
emit LogDydxFlashPayback(tokens, amts, totalAmtFees);
}
}
contract ConnectDydxFlashloan is LiquidityAccessMulti {
string public name = "dYdX-flashloan-v2.0";
}
| 278,641 | 10,764 |
675395834d89b2e786a95bab22ea956599bcf05c2405212a2571db0bd4168f84
| 26,130 |
.sol
|
Solidity
| false |
287303317
|
GrapFinance/grap-protocol
|
34df44b6bacadb3bfa8782671307dc57788df64e
|
contracts/distribution/GRAPETH_UNIV_Pool.sol
| 3,907 | 14,299 |
pragma solidity ^0.5.0;
// File: @openzeppelin/contracts/math/Math.sol
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
// File: @openzeppelin/contracts/math/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// File: @openzeppelin/contracts/GSN/Context.sol
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () 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;
}
}
// File: @openzeppelin/contracts/ownership/Ownable.sol
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;
}
}
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: @openzeppelin/contracts/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// File: contracts/IRewardDistributionRecipient.sol
contract IRewardDistributionRecipient is Ownable {
address public rewardDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardDistribution() {
require(_msgSender() == rewardDistribution, "Caller is not reward distribution");
_;
}
function setRewardDistribution(address _rewardDistribution)
external
onlyOwner
{
rewardDistribution = _rewardDistribution;
}
}
// File: contracts/CurveRewards.sol
interface GRAP {
function grapsScalingFactor() external returns (uint256);
}
contract LPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public eth_grap_univ = IERC20(0xC09fb8E468274a683A7570D0b795f8244FBEFf9C);
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
eth_grap_univ.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
eth_grap_univ.safeTransfer(msg.sender, amount);
}
}
contract GRAPETH_UNIV_Pool is LPTokenWrapper, IRewardDistributionRecipient {
IERC20 public grap = IERC20(0xC8D2AB2a6FdEbC25432E54941cb85b55b9f152dB);
uint256 public constant DURATION = 3024000; // ~5 weeks
uint256 public starttime = 1599436800; // 2020-09-07 00:00:00 (UTC +00:00)
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier checkStart() {
require(block.timestamp >= starttime,"not start");
_;
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
// stake visibility is public as overriding LPTokenWrapper's stake() function
function stake(uint256 amount) public updateReward(msg.sender) checkStart {
require(amount > 0, "Cannot stake 0");
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkStart {
require(amount > 0, "Cannot withdraw 0");
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) checkStart {
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
uint256 scalingFactor = GRAP(address(grap)).grapsScalingFactor();
uint256 trueReward = reward.mul(scalingFactor).div(10**18);
grap.safeTransfer(msg.sender, trueReward);
emit RewardPaid(msg.sender, trueReward);
}
}
function notifyRewardAmount(uint256 reward)
external
onlyRewardDistribution
updateReward(address(0))
{
if (block.timestamp > starttime) {
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(DURATION);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(DURATION);
}
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(DURATION);
emit RewardAdded(reward);
} else {
rewardRate = reward.div(DURATION);
lastUpdateTime = starttime;
periodFinish = starttime.add(DURATION);
emit RewardAdded(reward);
}
// avoid overflow to lock assets
uint256 check = DURATION.mul(rewardRate).mul(1e18);
}
}
| 334,288 | 10,765 |
fa811ae7449049a2f3cc0cce77271b7bc03e70bb0653ced9c04b930162f7eedd
| 28,705 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x824c38A5a3a94B13B0DFE48e534d7B717964e276/contract.sol
| 5,047 | 18,052 |
// Token: PolkaSocks
// Symbol: PKS
// Total Supply: 500 $PKS
// Website: https://www.polkasockspks.space/
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract PolkaSocks is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 500 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Polka Socks';
string private constant _symbol = 'PKS';
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x1a428f75A5893B54d1CE806B5661f5D8F41a12c6, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_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(0)).div(0);
uint256 tBurn = ((tAmount.mul(burnFee)).div(0)).div(0);
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;
}
}
| 257,911 | 10,766 |
663fb79788405e65dc76f7763ef25db15cd0398c445f40aa32941b7df912dc84
| 24,842 |
.sol
|
Solidity
| false |
464846914
|
1052445594/ScrawlD
|
fe09170b492d3757050b3e5e14430140a3407b45
|
contracts/0x549baffcf15d3dd5b01d93516b4ac4c3ba205991.sol
| 4,584 | 17,815 |
pragma solidity ^0.4.20;
contract GoldMain {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[keccak256(_customerAddress)]);
_;
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
// are we still in the vulnerable phase?
// if so, enact anti early whale protocol
if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){
require(// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Gold";
string public symbol = "INDG";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 4;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 1 token)
uint256 public stakingRequirement = 1e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 2.0 ether;
uint256 constant internal ambassadorQuota_ = 2.0 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(bytes32 => bool) public administrators;
bool public onlyAmbassadors = true;
function GaGold()
public
{
// add administrators here
administrators[keccak256(0x975AcB601D4469B45bE194e64073A9426c441279)] = true;
// add the ambassadors here.
ambassadors_[0x975AcB601D4469B45bE194e64073A9426c441279] = true;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw()
onlyStronghands()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// (we dont want whale premines)
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(_amountOfTokens, dividendFee_);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(bytes32 _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a masternode?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 229,471 | 10,767 |
33f7442a949d4004c85e5c2b9d832b2a28cc45775d0defd65dde47eb072e394c
| 13,858 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/20/20c2622fBe78F01DF571E462b85C19Ca13625e90_ERC20REBASE.sol
| 3,366 | 13,161 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
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;
}
}
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());
_;
}
function transferOwnership(address _newOwner) public virtual onlyOwner {
emit OwnershipTransferred(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function sync() external;
}
interface IDEXRouter {
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;
}
interface ICamelotRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
address referrer,
uint deadline) external;
}
contract permission {
mapping(address => mapping(string => bytes32)) private permit;
function newpermit(address adr,string memory str) internal { permit[adr][str] = bytes32(keccak256(abi.encode(adr,str))); }
function clearpermit(address adr,string memory str) internal { permit[adr][str] = bytes32(keccak256(abi.encode("null"))); }
function checkpermit(address adr,string memory str) public view returns (bool) {
if(permit[adr][str]==bytes32(keccak256(abi.encode(adr,str)))){ return true; }else{ return false; }
}
}
contract ERC20REBASE is permission,Ownable {
event Rebase(uint256 oldSupply,uint256 newSupply);
event Transfer(address indexed from,address indexed to,uint256 amount);
event Approval(address indexed from,address indexed to,uint256 amount);
string public name = "Tester Rebase V2";
string public symbol = "TRV2";
uint256 public decimals = 9;
uint256 public currentSupply = 1_000_000 * (10**decimals);
IDEXRouter public router;
address public pair;
address public marketingWallet;
address public LpReceiver;
uint256 public rebasethreshold = 9_992_375;
uint256 public rebaseratio = 10_000_000;
uint256 public rebaseperiod = 900;
uint256 public initialFlagment = 1e9;
uint256 public currentFlagment = initialFlagment;
uint256 public mintedSupply;
uint256 public lastrebaseblock;
bool public rebasegenesis;
uint256 public fee_Liquidity = 1;
uint256 public fee_marketing = 2;
uint256 public fee_Total = 3;
uint256 public denominator = 100;
uint256 public swapthreshold;
bool public autoRebase = true;
bool public enableTrade;
bool public isCamelotRouter;
bool inSwap;
mapping(address => uint256) public balances;
mapping(address => mapping(address => uint256)) public allowance;
constructor(address _marketingWallet,address _LpReceiver) {
balances[msg.sender] = currentSupply;
swapthreshold = toPercent(currentSupply,1,1000);
router = IDEXRouter(0xc873fEcbd354f5A56E00E710B90EF4201db2448d);
allowance[address(this)][address(router)] = type(uint256).max;
marketingWallet = _marketingWallet;
LpReceiver = _LpReceiver;
newpermit(msg.sender,"isFeeExempt");
newpermit(address(this),"isFeeExempt");
newpermit(address(router),"isFeeExempt");
emit Transfer(address(0), msg.sender, currentSupply);
}
function balanceOf(address adr) public view returns(uint256) {
return toFlagment(balances[adr]);
}
function balanceOfUnderlying(address adr) public view returns(uint256) {
return balances[adr];
}
function totalSupply() public view returns(uint256) {
return toFlagment(currentSupply+mintedSupply);
}
function approve(address to, uint256 amount) public returns (bool) {
allowance[msg.sender][to] = amount;
emit Approval(msg.sender, to, amount);
return true;
}
function transfer(address to, uint256 amount) public returns (bool) {
_transferFrom(msg.sender,to,toUnderlying(amount));
return true;
}
function transferFrom(address from, address to, uint256 amount) public returns(bool) {
uint256 checker = allowance[from][msg.sender];
if(checker!=type(uint256).max){
allowance[from][msg.sender] -= amount;
}
_transferFrom(from,to,toUnderlying(amount));
return true;
}
function _transferFrom(address from,address to, uint256 amountUnderlying) internal {
if(inSwap){
_transfer(from,to,amountUnderlying);
emit Transfer(from, to, toFlagment(amountUnderlying));
}else{
if(from==pair){ require(enableTrade,"Trading Was Not Live"); }
if(msg.sender!=pair && balances[address(this)]>swapthreshold){
inSwap = true;
uint256 amountToMarketing = toPercent(swapthreshold,fee_marketing,fee_Total);
uint256 currentthreshold = swapthreshold - amountToMarketing;
uint256 amountToLiquify = currentthreshold / 2;
uint256 amountToSwap = amountToMarketing + amountToLiquify;
uint256 balanceBefore = address(this).balance;
swap2ETH(amountToSwap);
uint256 balanceAfter = address(this).balance - balanceBefore;
uint256 amountReserved = toPercent(balanceAfter,amountToMarketing,amountToSwap);
uint256 amountLP = balanceAfter - amountReserved;
(bool success,) = marketingWallet.call{ value: amountReserved }("");
require(success);
autoAddLP(amountToLiquify,amountLP);
inSwap = false;
}
_transfer(from,to,amountUnderlying);
uint256 tempTotalFee = 0;
if(from==pair && !checkpermit(to,"isFeeExempt")){ tempTotalFee = toPercent(amountUnderlying,fee_Total,denominator); }
if(to==pair && !checkpermit(from,"isFeeExempt")){ tempTotalFee = toPercent(amountUnderlying,fee_Total,denominator); }
if(tempTotalFee>0){
_transfer(to,address(this),tempTotalFee);
emit Transfer(from,address(this),toFlagment(tempTotalFee));
}
emit Transfer(from, to, toFlagment(amountUnderlying-tempTotalFee));
if(_shouldRebase()) { _rebase(); }
}
}
function _transfer(address from,address to, uint256 amount) internal {
balances[from] -= amount;
balances[to] += amount;
}
function requestSupply(address to, uint256 amount) public returns (bool) {
require(checkpermit(msg.sender,"masterSoul"));
balances[to] += amount;
mintedSupply += amount;
emit Transfer(address(0), to, toFlagment(amount));
return true;
}
function manualrebase() public returns (bool) {
if(_shouldRebase()){ _rebase(); }
return true;
}
function getNextRebase() public view returns (uint256) {
if(block.timestamp>lastrebaseblock+rebaseperiod){
return 0;
}else{
return lastrebaseblock + rebaseperiod - block.timestamp;
}
}
function _shouldRebase() internal view returns (bool) {
if(lastrebaseblock>0
&& block.timestamp - lastrebaseblock > rebaseperiod
&& autoRebase
&& msg.sender!=pair
&& msg.sender!=address(router)){ return true; }else{ return false; }
}
function _rebase() internal {
uint256 currentperiod = block.timestamp - lastrebaseblock;
uint256 beforerebase = currentFlagment;
uint256 i = 0;
uint256 max = currentperiod / rebaseperiod;
do{
i++;
currentFlagment = currentFlagment * rebasethreshold / rebaseratio;
}while(i<max);
lastrebaseblock = block.timestamp;
IDEXFactory(pair).sync();
emit Rebase(beforerebase,currentFlagment);
}
function toPercent(uint256 _amount,uint256 _percent,uint256 _denominator) internal pure returns (uint256) {
return _amount * _percent / _denominator;
}
function toFlagment(uint256 value) public view returns (uint256) {
return value * currentFlagment / initialFlagment;
}
function toUnderlying(uint256 value) public view returns (uint256) {
return value * initialFlagment / currentFlagment;
}
function swap2ETH(uint256 amount) internal {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
if(isCamelotRouter){
ICamelotRouter crouter = ICamelotRouter(address(router));
crouter.swapExactTokensForETHSupportingFeeOnTransferTokens(amount,
0,
path,
address(this),
address(0),
block.timestamp);
}else{
router.swapExactTokensForETHSupportingFeeOnTransferTokens(amount,
0,
path,
address(this),
block.timestamp);
}
}
function autoAddLP(uint256 amountToLiquify,uint256 amountETH) internal {
router.addLiquidityETH{value: amountETH }(address(this),
amountToLiquify,
0,
0,
LpReceiver,
block.timestamp);
}
function enableTrading() public onlyOwner returns (bool) {
require(!enableTrade,"Trading Already Live");
enableTrade = true;
return true;
}
function startRebasing() public onlyOwner returns (bool) {
require(!rebasegenesis,"Rebase Genesis Was Started");
rebasegenesis = true;
lastrebaseblock = block.timestamp;
return true;
}
function camelotRouterToggle() public onlyOwner returns (bool) {
isCamelotRouter = !isCamelotRouter;
return true;
}
function autoRebaseToggle() public onlyOwner returns (bool) {
autoRebase = !autoRebase;
return true;
}
function changeSwapThreshold(uint256 swapamount) public onlyOwner returns (bool) {
swapthreshold = swapamount;
return true;
}
function changeMarketingWallet(address _marketingWallet) public onlyOwner returns (bool) {
marketingWallet = _marketingWallet;
return true;
}
function changeLPReceiver(address _LpReceiver) public onlyOwner returns (bool) {
LpReceiver = _LpReceiver;
return true;
}
function changeLiquidityPair(address _pair) public onlyOwner returns (bool) {
pair = _pair;
return true;
}
function settingRebaseRule(uint256 _threshold,uint256 _ratio,uint256 _period) public onlyOwner returns (bool) {
rebasethreshold = _threshold;
rebaseratio = _ratio;
rebaseperiod = _period;
return true;
}
function settingFeeAmount(uint256 _marketing,uint256 _liquidity) public onlyOwner returns (bool) {
require(_marketing + _liquidity <= 25,"Safe Token Fee Must Less Than Or Equal To 25%");
fee_marketing = _marketing;
fee_Liquidity = _liquidity;
fee_Total = _marketing + _liquidity;
return true;
}
function approval(address erc20,address operator,uint256 amount) public onlyOwner returns (bool) {
IERC20(erc20).approve(operator,amount);
return true;
}
function grantRole(address adr,string memory role) public onlyOwner returns (bool) {
newpermit(adr,role);
return true;
}
function revokeRole(address adr,string memory role) public onlyOwner returns (bool) {
clearpermit(adr,role);
return true;
}
receive() external payable {}
}
| 28,378 | 10,768 |
02cae68e2a10a88ac5314a6e5af46ec3648e8a6ffca3191e23a98deb7cb47946
| 22,232 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x0298208f41839446491e6bbd7a850de1c80a9659.sol
| 5,806 | 22,008 |
pragma solidity =0.8.0;
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);
function getOwner() external view returns (address);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed from, address indexed to);
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), owner);
}
modifier onlyOwner {
require(msg.sender == owner, "Ownable: Caller is not the owner");
_;
}
function transferOwnership(address transferOwner) external onlyOwner {
require(transferOwner != newOwner);
newOwner = transferOwner;
}
function acceptOwnership() virtual public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract ARK420 is IERC20, Ownable, Pausable {
mapping (address => mapping (address => uint)) private _allowances;
mapping (address => uint) private _unfrozenBalances;
mapping (address => uint) private _vestingNonces;
mapping (address => mapping (uint => uint)) private _vestingAmounts;
mapping (address => mapping (uint => uint)) private _unvestedAmounts;
mapping (address => mapping (uint => uint)) private _vestingTypes; //0 - multivest, 1 - single vest, > 2 give by vester id
mapping (address => mapping (uint => uint)) private _vestingReleaseStartDates;
mapping (address => mapping (uint => uint)) private _vestingSecondPeriods;
uint private _totalSupply = 4_200_000_000e18;
string private constant _name = "ARK420";
string private constant _symbol = "ARK420";
uint8 private constant _decimals = 18;
uint public constant vestingSaleReleaseStart = 1650412800; // 00:00:00 20 April 2022 GMT+00:00 1650412800
uint public constant vestingSaleSecondPeriod = 365 days; // 1/365 each day
uint public constant vestingFoundationReleaseStart = 1642809600 + 60 days; // 00:00:00 22 January 2022 GMT+00:00 + 2 Months 2022 GMT+00:00 1642809600
uint public constant vestingFoundationSecondPeriod = 1 seconds; // immediately release
address public stakingContract; // can be set once
uint public constant stakingContractRelease = 1650412800; // 00:00:00 20 April 2022 GMT+00:00 1650412800
uint public stakingAmount; // will be transferred all at once to specific contract after release time
address public liquidityContract; // can be set once
uint public constant liquidityContractRelease = 1650412800; // 00:00:00 20 April 2022 GMT+00:00 1650412800
uint public liquidityAmount; // will be transferred all at once to specific contract after release time
address public exchangeListingContract; // can be set once
uint public constant exchangeListingContractRelease = 1650412800; // 00:00:00 20 April 2022 GMT+00:00 1650412800
uint public exchangeListingAmount; // will be transferred all at once to specific contract after release time
address public advisorsAndTeamContract; // can be set once
uint public constant advisorsAndTeamContractRelease = 1642809600 + 14 days; // 00:00:00 22 January 2022 GMT+00:00 + 2 Weeks 1642809600
uint public advisorsAndTeamAmount; // will be transferred all at once to specific contract after release time
uint public giveAmount;
mapping (address => bool) public vesters;
bytes32 public immutable DOMAIN_SEPARATOR;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
mapping (address => uint) public nonces;
event Unvest(address indexed user, uint amount);
constructor (address[] memory foundation, address support) {
require(support != address(0), "ARK420: Zero address");
require(support != msg.sender, "ARK420: Owner can't be support address");
_unfrozenBalances[owner] = _totalSupply;
uint256 toFoundation = _totalSupply * 25 / 100; // 25% to foundation
for (uint i = 0; i < foundation.length; i++) {
_vest(foundation[i], toFoundation / foundation.length, 1, vestingFoundationReleaseStart, vestingFoundationReleaseStart + vestingFoundationSecondPeriod);
}
uint256 toAdvisors = _totalSupply * 5 / 100; // 5% to advisors
uint256 toTeam = _totalSupply * 11 / 100; // 11% to team
advisorsAndTeamAmount += toAdvisors + toTeam;
_unfrozenBalances[owner] -= advisorsAndTeamAmount;
uint256 toExchangeListing = _totalSupply * 8 / 100; // 8% to exchange listing
exchangeListingAmount += toExchangeListing;
_unfrozenBalances[owner] -= exchangeListingAmount;
uint256 toStaking = _totalSupply * 25 / 100; // 25% to staking
stakingAmount += toStaking;
_unfrozenBalances[owner] -= stakingAmount;
uint256 toLiquidity = _totalSupply * 1 / 100; // 1% to liquidity
liquidityAmount += toLiquidity;
_unfrozenBalances[owner] -= liquidityAmount;
uint256 toSupport = _unfrozenBalances[owner] * 4 / 100; // 4% of public sale to vested for support wallet
_vest(support, toSupport, 1, vestingSaleReleaseStart, vestingSaleReleaseStart + vestingSaleSecondPeriod);
emit Transfer(address(0), owner, _unfrozenBalances[owner]);
uint chainId = block.chainid;
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256('EIP712Domain(string name,uint256 chainId,address verifyingContract)'),
keccak256(bytes(_name)),
chainId,
address(this)));
giveAmount = _totalSupply / 10;
}
receive() payable external {
revert();
}
function getOwner() public override view returns (address) {
return owner;
}
function approve(address spender, uint amount) external override whenNotPaused returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transfer(address recipient, uint amount) external override whenNotPaused returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) external override whenNotPaused returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][msg.sender];
require(currentAllowance >= amount, "ARK420::transferFrom: transfer amount exceeds allowance");
_approve(sender, msg.sender, currentAllowance - amount);
return true;
}
function permit(address owner, address spender, uint amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external whenNotPaused {
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, amount, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "ARK420::permit: invalid signature");
require(signatory == owner, "ARK420::permit: unauthorized");
require(block.timestamp <= deadline, "ARK420::permit: signature expired");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function increaseAllowance(address spender, uint addedValue) external returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) external returns (bool) {
uint256 currentAllowance = _allowances[msg.sender][spender];
require(currentAllowance >= subtractedValue, "ARK420::decreaseAllowance: decreased allowance below zero");
_approve(msg.sender, spender, currentAllowance - subtractedValue);
return true;
}
function unvest() external whenNotPaused returns (uint unvested) {
require (_vestingNonces[msg.sender] > 0, "ARK420::unvest:No vested amount");
for (uint i = 1; i <= _vestingNonces[msg.sender]; i++) {
if (_vestingAmounts[msg.sender][i] == _unvestedAmounts[msg.sender][i]) continue;
if (_vestingReleaseStartDates[msg.sender][i] > block.timestamp) break;
uint toUnvest = (block.timestamp - _vestingReleaseStartDates[msg.sender][i]) * _vestingAmounts[msg.sender][i] / (_vestingSecondPeriods[msg.sender][i] - _vestingReleaseStartDates[msg.sender][i]);
if (toUnvest > _vestingAmounts[msg.sender][i]) {
toUnvest = _vestingAmounts[msg.sender][i];
}
uint totalUnvestedForNonce = toUnvest;
toUnvest -= _unvestedAmounts[msg.sender][i];
unvested += toUnvest;
_unvestedAmounts[msg.sender][i] = totalUnvestedForNonce;
}
_unfrozenBalances[msg.sender] += unvested;
emit Unvest(msg.sender, unvested);
}
function give(address user, uint amount, uint vesterId) external {
require (giveAmount > amount, "ARK420::give: give finished");
require (vesters[msg.sender], "ARK420::give: not vester");
giveAmount -= amount;
_vest(user, amount, vesterId, vestingSaleReleaseStart, vestingSaleReleaseStart + vestingSaleSecondPeriod);
}
function vest(address user, uint amount) external {
require (vesters[msg.sender], "ARK420::vest: not vester");
_vest(user, amount, 1, vestingSaleReleaseStart, vestingSaleReleaseStart + vestingSaleSecondPeriod);
}
function setAdvisorsAndTeamContract(address advisorsAndTeam) external onlyOwner {
require (advisorsAndTeam != address(0), "ARK420::setAdvisorsAndTeamContract: advisors and team address should be non zero");
require (advisorsAndTeamContract == address(0), "ARK420::setAdvisorsAndTeamContract: advisors and team address already set");
advisorsAndTeamContract = advisorsAndTeam;
}
function releaseToAdvisorsAndTeamContract() external onlyOwner {
require (advisorsAndTeamContract != address(0), "ARK420::releaseToAdvisorsAndTeamContract: Advisors And Team Contract address should be set");
require (advisorsAndTeamAmount > 0, "ARK420::releaseToAdvisorsAndTeamContract: Advisors And Team Contract amount should be more then 0");
require(block.timestamp > advisorsAndTeamContractRelease, "ARK420::releaseToAdvisorsAndTeamContract: too early to release Advisors And Team amount");
_unfrozenBalances[advisorsAndTeamContract] += advisorsAndTeamAmount;
advisorsAndTeamAmount = 0;
emit Transfer(address(0), advisorsAndTeamContract, _unfrozenBalances[advisorsAndTeamContract]);
}
function setExchangeListingContract(address exchangeListing) external onlyOwner {
require (exchangeListing != address(0), "ARK420::setExchangeListingContract: exchange listing address should be non zero");
require (exchangeListingContract == address(0), "ARK420::setExchangeListingContract: exchange listing address already set");
exchangeListingContract = exchangeListing;
}
function releaseToExchangeListingContract() external onlyOwner {
require (exchangeListingContract != address(0), "ARK420::releaseToExchangeListingContract: Exchange Listing address should be set");
require (exchangeListingAmount > 0, "ARK420::releaseToExchangeListingContract: Exchange Listing amount should be more then 0");
require(block.timestamp > exchangeListingContractRelease, "ARK420::releaseToExchangeListingContract: too early to release ExchangeListing amount");
_unfrozenBalances[exchangeListingContract] += exchangeListingAmount;
exchangeListingAmount = 0;
emit Transfer(address(0), exchangeListingContract, _unfrozenBalances[exchangeListingContract]);
}
function setLiquidityContract(address liquidity) external onlyOwner {
require (liquidity != address(0), "ARK420::setLiquidityContract: liquidity address should be non zero");
require (liquidityContract == address(0), "ARK420::setLiquidityContract: liquidity address already set");
liquidityContract = liquidity;
}
function releaseToLiquidityContract() external onlyOwner {
require (liquidityContract != address(0), "ARK420::releaseToLiquidityContract: liquidity address should be set");
require (liquidityAmount > 0, "ARK420::releaseToLiquidityContract: liquidity amount should be more then 0");
require(block.timestamp > liquidityContractRelease, "ARK420::releaseToLiquidityContract: too early to release liquidity amount");
_unfrozenBalances[liquidityContract] += liquidityAmount;
liquidityAmount = 0;
emit Transfer(address(0), liquidityContract, _unfrozenBalances[liquidityContract]);
}
function setStakingContract(address staking) external onlyOwner {
require (staking != address(0), "ARK420::setStakingContract: staking address should be non zero");
require (stakingContract == address(0), "ARK420::setStakingContract: staking address already set");
stakingContract = staking;
}
function releaseToStakingContract() external onlyOwner {
require (stakingContract != address(0), "ARK420::releaseToStaking: staking address should be set");
require (stakingAmount > 0, "ARK420::releaseToStaking: staking amount should be more then 0");
require(block.timestamp > stakingContractRelease, "ARK420::releaseToStaking: too early to release staking amount");
_unfrozenBalances[stakingContract] += stakingAmount;
stakingAmount = 0;
emit Transfer(address(0), stakingContract, _unfrozenBalances[stakingContract]);
}
function vestPurchase(address user, uint amount) external {
require (vesters[msg.sender], "ARK420::vestPurchase: not vester");
_transfer(msg.sender, owner, amount);
_vest(user, amount, 1, vestingSaleReleaseStart, vestingSaleReleaseStart + vestingSaleSecondPeriod);
}
function burnTokens(uint amount) external onlyOwner returns (bool success) {
require(amount <= _unfrozenBalances[owner], "ARK420::burnTokens: exceeds available amount");
uint256 ownerBalance = _unfrozenBalances[owner];
require(ownerBalance >= amount, "ARK420::burnTokens: burn amount exceeds owner balance");
_unfrozenBalances[owner] = ownerBalance - amount;
_totalSupply -= amount;
emit Transfer(owner, address(0), amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint) {
return _allowances[owner][spender];
}
function decimals() external override pure returns (uint8) {
return _decimals;
}
function name() external pure returns (string memory) {
return _name;
}
function symbol() external pure returns (string memory) {
return _symbol;
}
function totalSupply() external view override returns (uint) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint) {
uint amount = _unfrozenBalances[account];
if (_vestingNonces[account] == 0) return amount;
for (uint i = 1; i <= _vestingNonces[account]; i++) {
amount = amount + _vestingAmounts[account][i] - _unvestedAmounts[account][i];
}
return amount;
}
function availableForUnvesting(address user) external view returns (uint unvestAmount) {
if (_vestingNonces[user] == 0) return 0;
for (uint i = 1; i <= _vestingNonces[user]; i++) {
if (_vestingAmounts[user][i] == _unvestedAmounts[user][i]) continue;
if (_vestingReleaseStartDates[user][i] > block.timestamp) break;
uint toUnvest = (block.timestamp - _vestingReleaseStartDates[user][i]) * _vestingAmounts[user][i] / (_vestingSecondPeriods[user][i] - _vestingReleaseStartDates[user][i]);
if (toUnvest > _vestingAmounts[user][i]) {
toUnvest = _vestingAmounts[user][i];
}
toUnvest -= _unvestedAmounts[user][i];
unvestAmount += toUnvest;
}
}
function availableForTransfer(address account) external view returns (uint) {
return _unfrozenBalances[account];
}
function vestingInfo(address user, uint nonce) external view returns (uint vestingAmount, uint unvestedAmount, uint vestingReleaseStartDate, uint vestingSecondPeriod, uint vestType) {
vestingAmount = _vestingAmounts[user][nonce];
unvestedAmount = _unvestedAmounts[user][nonce];
vestingReleaseStartDate = _vestingReleaseStartDates[user][nonce];
vestingSecondPeriod = _vestingSecondPeriods[user][nonce];
vestType = _vestingTypes[user][nonce];
}
function vestingNonces(address user) external view returns (uint lastNonce) {
return _vestingNonces[user];
}
function _approve(address owner, address spender, uint amount) private {
require(owner != address(0), "ARK420::_approve: approve from the zero address");
require(spender != address(0), "ARK420::_approve: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint amount) private {
require(sender != address(0), "ARK420::_transfer: transfer from the zero address");
require(recipient != address(0), "ARK420::_transfer: transfer to the zero address");
uint256 senderAvailableBalance = _unfrozenBalances[sender];
require(senderAvailableBalance >= amount, "ARK420::_transfer: amount exceeds available for transfer balance");
_unfrozenBalances[sender] = senderAvailableBalance - amount;
_unfrozenBalances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function _vest(address user, uint amount, uint vestType, uint vestingReleaseStart, uint vestingReleaseSecondPeriod) private {
require(user != address(0), "ARK420::_vest: vest to the zero address");
require(vestingReleaseStart >= 0, "ARK420::_vest: vesting release start date should be more then 0");
require(vestingReleaseSecondPeriod >= vestingReleaseStart, "ARK420::_vest: vesting release end date should be more then start date");
uint nonce = ++_vestingNonces[user];
_vestingAmounts[user][nonce] = amount;
_vestingReleaseStartDates[user][nonce] = vestingReleaseStart;
_vestingSecondPeriods[user][nonce] = vestingReleaseSecondPeriod;
_unfrozenBalances[owner] -= amount;
_vestingTypes[user][nonce] = vestType;
emit Transfer(owner, user, amount);
}
function multisend(address[] memory to, uint[] memory values) external onlyOwner returns (uint) {
require(to.length == values.length);
require(to.length < 100);
uint sum;
for (uint j; j < values.length; j++) {
sum += values[j];
}
_unfrozenBalances[owner] -= sum;
for (uint i; i < to.length; i++) {
_unfrozenBalances[to[i]] += values[i];
emit Transfer(owner, to[i], values[i]);
}
return(to.length);
}
function multivest(address[] memory to, uint[] memory values, uint[] memory vestingReleaseStarts, uint[] memory vestingSecondPeriods) external onlyOwner returns (uint) {
require(to.length == values.length);
require(to.length < 100);
uint sum;
for (uint j; j < values.length; j++) {
sum += values[j];
}
_unfrozenBalances[owner] -= sum;
for (uint i; i < to.length; i++) {
uint nonce = ++_vestingNonces[to[i]];
_vestingAmounts[to[i]][nonce] = values[i];
_vestingReleaseStartDates[to[i]][nonce] = vestingReleaseStarts[i];
_vestingSecondPeriods[to[i]][nonce] = vestingSecondPeriods[i];
_vestingTypes[to[i]][nonce] = 0;
emit Transfer(owner, to[i], values[i]);
}
return(to.length);
}
function updateVesters(address vester, bool isActive) external onlyOwner {
vesters[vester] = isActive;
}
function updateGiveAmount(uint amount) external onlyOwner {
require (_unfrozenBalances[owner] > amount, "ARK420::updateGiveAmount: exceed owner balance");
giveAmount = amount;
}
function transferAnyERC20Token(address tokenAddress, uint tokens) external onlyOwner returns (bool success) {
return IERC20(tokenAddress).transfer(owner, tokens);
}
function acceptOwnership() public override {
uint amount = _unfrozenBalances[owner];
_unfrozenBalances[newOwner] = amount;
_unfrozenBalances[owner] = 0;
emit Transfer(owner, newOwner, amount);
super.acceptOwnership();
}
}
| 275,456 | 10,769 |
992558977230568668e94f7768c0db76e67cc78f437116c73421da17cf7c8d02
| 10,278 |
.sol
|
Solidity
| false |
595977925
|
0xToshii/mr-steal-yo-crypto-ctf-foundry
|
5fc5c109d451b427bbe30dbe9cdf268536bf161f
|
src/other/ERC1820Registry.sol
| 2,298 | 9,258 |
pragma solidity 0.5.3;
// IV is value needed to have a vanity address starting with '0x1820'.
// IV: 53759
/// @dev The interface a contract MUST implement if it is the implementer of
/// some (other) interface for any address other than itself.
interface ERC1820ImplementerInterface {
/// @param interfaceHash keccak256 hash of the name of the interface
/// @param addr Address for which the contract will implement the interface
function canImplementInterfaceForAddress(bytes32 interfaceHash, address addr) external view returns(bytes32);
}
/// @title ERC1820 Pseudo-introspection Registry Contract
/// @author Jordi Baylina and Jacques Dafflon
/// @notice This contract is the official implementation of the ERC1820 Registry.
/// @notice For more details, see https://eips.ethereum.org/EIPS/eip-1820
contract ERC1820Registry {
/// @notice ERC165 Invalid ID.
bytes4 constant internal INVALID_ID = 0xffffffff;
bytes4 constant internal ERC165ID = 0x01ffc9a7;
bytes32 constant internal ERC1820_ACCEPT_MAGIC = keccak256(abi.encodePacked("ERC1820_ACCEPT_MAGIC"));
/// @notice mapping from addresses and interface hashes to their implementers.
mapping(address => mapping(bytes32 => address)) internal interfaces;
/// @notice mapping from addresses to their manager.
mapping(address => address) internal managers;
/// @notice flag for each address and erc165 interface to indicate if it is cached.
mapping(address => mapping(bytes4 => bool)) internal erc165Cached;
/// @notice Indicates a contract is the 'implementer' of 'interfaceHash' for 'addr'.
event InterfaceImplementerSet(address indexed addr, bytes32 indexed interfaceHash, address indexed implementer);
/// @notice Indicates 'newManager' is the address of the new manager for 'addr'.
event ManagerChanged(address indexed addr, address indexed newManager);
/// @notice Query if an address implements an interface and through which contract.
/// @param _addr Address being queried for the implementer of an interface.
/// (If '_addr' is the zero address then 'msg.sender' is assumed.)
/// @param _interfaceHash Keccak256 hash of the name of the interface as a string.
/// E.g., 'web3.utils.keccak256("ERC777TokensRecipient")' for the 'ERC777TokensRecipient' interface.
/// @return The address of the contract which implements the interface '_interfaceHash' for '_addr'
/// or '0' if '_addr' did not register an implementer for this interface.
function getInterfaceImplementer(address _addr, bytes32 _interfaceHash) external view returns (address) {
address addr = _addr == address(0) ? msg.sender : _addr;
if (isERC165Interface(_interfaceHash)) {
bytes4 erc165InterfaceHash = bytes4(_interfaceHash);
return implementsERC165Interface(addr, erc165InterfaceHash) ? addr : address(0);
}
return interfaces[addr][_interfaceHash];
}
/// @notice Sets the contract which implements a specific interface for an address.
/// Only the manager defined for that address can set it.
/// (Each address is the manager for itself until it sets a new manager.)
/// @param _addr Address for which to set the interface.
/// (If '_addr' is the zero address then 'msg.sender' is assumed.)
/// @param _interfaceHash Keccak256 hash of the name of the interface as a string.
/// E.g., 'web3.utils.keccak256("ERC777TokensRecipient")' for the 'ERC777TokensRecipient' interface.
/// @param _implementer Contract address implementing '_interfaceHash' for '_addr'.
function setInterfaceImplementer(address _addr, bytes32 _interfaceHash, address _implementer) external {
address addr = _addr == address(0) ? msg.sender : _addr;
require(getManager(addr) == msg.sender, "Not the manager");
require(!isERC165Interface(_interfaceHash), "Must not be an ERC165 hash");
if (_implementer != address(0) && _implementer != msg.sender) {
require(ERC1820ImplementerInterface(_implementer)
.canImplementInterfaceForAddress(_interfaceHash, addr) == ERC1820_ACCEPT_MAGIC,
"Does not implement the interface");
}
interfaces[addr][_interfaceHash] = _implementer;
emit InterfaceImplementerSet(addr, _interfaceHash, _implementer);
}
/// @notice Sets '_newManager' as manager for '_addr'.
/// The new manager will be able to call 'setInterfaceImplementer' for '_addr'.
/// @param _addr Address for which to set the new manager.
function setManager(address _addr, address _newManager) external {
require(getManager(_addr) == msg.sender, "Not the manager");
managers[_addr] = _newManager == _addr ? address(0) : _newManager;
emit ManagerChanged(_addr, _newManager);
}
/// @notice Get the manager of an address.
/// @param _addr Address for which to return the manager.
/// @return Address of the manager for a given address.
function getManager(address _addr) public view returns(address) {
// By default the manager of an address is the same address
if (managers[_addr] == address(0)) {
return _addr;
} else {
return managers[_addr];
}
}
/// @notice Compute the keccak256 hash of an interface given its name.
/// @param _interfaceName Name of the interface.
/// @return The keccak256 hash of an interface name.
function interfaceHash(string calldata _interfaceName) external pure returns(bytes32) {
return keccak256(abi.encodePacked(_interfaceName));
}
/// @notice Updates the cache with whether the contract implements an ERC165 interface or not.
/// @param _contract Address of the contract for which to update the cache.
/// @param _interfaceId ERC165 interface for which to update the cache.
function updateERC165Cache(address _contract, bytes4 _interfaceId) external {
interfaces[_contract][_interfaceId] = implementsERC165InterfaceNoCache(_contract, _interfaceId) ? _contract : address(0);
erc165Cached[_contract][_interfaceId] = true;
}
/// @notice Checks whether a contract implements an ERC165 interface or not.
// If the result is not cached a direct lookup on the contract address is performed.
// 'updateERC165Cache' with the contract address.
/// @param _contract Address of the contract to check.
/// @param _interfaceId ERC165 interface to check.
/// @return True if '_contract' implements '_interfaceId', false otherwise.
function implementsERC165Interface(address _contract, bytes4 _interfaceId) public view returns (bool) {
if (!erc165Cached[_contract][_interfaceId]) {
return implementsERC165InterfaceNoCache(_contract, _interfaceId);
}
return interfaces[_contract][_interfaceId] == _contract;
}
/// @param _contract Address of the contract to check.
/// @param _interfaceId ERC165 interface to check.
/// @return True if '_contract' implements '_interfaceId', false otherwise.
function implementsERC165InterfaceNoCache(address _contract, bytes4 _interfaceId) public view returns (bool) {
uint256 success;
uint256 result;
(success, result) = noThrowCall(_contract, ERC165ID);
if (success == 0 || result == 0) {
return false;
}
(success, result) = noThrowCall(_contract, INVALID_ID);
if (success == 0 || result != 0) {
return false;
}
(success, result) = noThrowCall(_contract, _interfaceId);
if (success == 1 && result == 1) {
return true;
}
return false;
}
/// @notice Checks whether the hash is a ERC165 interface (ending with 28 zeroes) or not.
/// @param _interfaceHash The hash to check.
/// @return True if '_interfaceHash' is an ERC165 interface (ending with 28 zeroes), false otherwise.
function isERC165Interface(bytes32 _interfaceHash) internal pure returns (bool) {
return _interfaceHash & 0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0;
}
/// @dev Make a call on a contract without throwing if the function does not exist.
function noThrowCall(address _contract, bytes4 _interfaceId)
internal view returns (uint256 success, uint256 result)
{
bytes4 erc165ID = ERC165ID;
assembly {
let x := mload(0x40) // Find empty storage location using "free memory pointer"
mstore(x, erc165ID) // Place signature at beginning of empty storage
mstore(add(x, 0x04), _interfaceId) // Place first argument directly next to signature
success := staticcall(30000, // 30k gas
_contract, // To addr
x, // Inputs are stored at location x
0x24, // Inputs are 36 (4 + 32) bytes long
x, // Store output over input (saves space)
0x20 // Outputs are 32 bytes long)
result := mload(x) // Load the result
}
}
}
| 306,884 | 10,770 |
d76b8639efbc22a44a8f90d5915bd3434ea9ff7a9e01d8d9dd165f7354d9a278
| 19,591 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x1748149ea200a9d1db395bf744f5266c97988637.sol
| 3,118 | 12,994 |
pragma solidity ^0.5.0;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract BNDESRegistry is Ownable() {
enum BlockchainAccountState {AVAILABLE,WAITING_VALIDATION,VALIDATED,INVALIDATED_BY_VALIDATOR,INVALIDATED_BY_CHANGE}
BlockchainAccountState blockchainState; //Not used. Defined to create the enum type.
address responsibleForSettlement;
address responsibleForRegistryValidation;
address responsibleForDisbursement;
address redemptionAddress;
address tokenAddress;
struct LegalEntityInfo {
uint64 cnpj; //Brazilian identification of legal entity
uint64 idFinancialSupportAgreement; //SCC contract
uint32 salic; //ANCINE identifier
string idProofHash; //hash of declaration
BlockchainAccountState state;
}
mapping(address => LegalEntityInfo) public legalEntitiesInfo;
mapping(uint64 => mapping(uint64 => address)) cnpjFSAddr;
mapping(address => bool) public legalEntitiesChangeAccount;
event AccountRegistration(address addr, uint64 cnpj, uint64 idFinancialSupportAgreement, uint32 salic, string idProofHash);
event AccountChange(address oldAddr, address newAddr, uint64 cnpj, uint64 idFinancialSupportAgreement, uint32 salic, string idProofHash);
event AccountValidation(address addr, uint64 cnpj, uint64 idFinancialSupportAgreement, uint32 salic);
event AccountInvalidation(address addr, uint64 cnpj, uint64 idFinancialSupportAgreement, uint32 salic);
modifier onlyTokenAddress() {
require(isTokenAddress());
_;
}
constructor () public {
responsibleForSettlement = msg.sender;
responsibleForRegistryValidation = msg.sender;
responsibleForDisbursement = msg.sender;
redemptionAddress = msg.sender;
}
function registryLegalEntity(uint64 cnpj, uint64 idFinancialSupportAgreement, uint32 salic,
address addr, string memory idProofHash) onlyTokenAddress public {
// Endereo no pode ter sido cadastrado anteriormente
require (isAvailableAccount(addr), "Endereo no pode ter sido cadastrado anteriormente");
require (isValidHash(idProofHash), "O hash da declarao invlido");
legalEntitiesInfo[addr] = LegalEntityInfo(cnpj, idFinancialSupportAgreement, salic, idProofHash, BlockchainAccountState.WAITING_VALIDATION);
// No pode haver outro endereo cadastrado para esse mesmo subcrdito
if (idFinancialSupportAgreement > 0) {
address account = getBlockchainAccount(cnpj,idFinancialSupportAgreement);
require (isAvailableAccount(account), "Cliente j est associado a outro endereo. Use a funo Troca.");
}
else {
address account = getBlockchainAccount(cnpj,0);
require (isAvailableAccount(account), "Fornecedor j est associado a outro endereo. Use a funo Troca.");
}
cnpjFSAddr[cnpj][idFinancialSupportAgreement] = addr;
emit AccountRegistration(addr, cnpj, idFinancialSupportAgreement, salic, idProofHash);
}
function changeAccountLegalEntity(uint64 cnpj, uint64 idFinancialSupportAgreement, uint32 salic,
address newAddr, string memory idProofHash) onlyTokenAddress public {
address oldAddr = getBlockchainAccount(cnpj, idFinancialSupportAgreement);
// Tem que haver um endereo associado a esse cnpj/subcrdito
require(!isReservedAccount(oldAddr), "No pode trocar endereo de conta reservada");
require(!isAvailableAccount(oldAddr), "Tem que haver um endereo associado a esse cnpj/subcrdito");
require(isAvailableAccount(newAddr), "Novo endereo no est disponvel");
require (isChangeAccountEnabled(oldAddr), "A conta atual no est habilitada para troca");
require (isValidHash(idProofHash), "O hash da declarao invlido");
require(legalEntitiesInfo[oldAddr].cnpj==cnpj
&& legalEntitiesInfo[oldAddr].idFinancialSupportAgreement ==idFinancialSupportAgreement,
"Dados inconsistentes de cnpj ou subcrdito");
// Aponta o novo endereo para o novo LegalEntityInfo
legalEntitiesInfo[newAddr] = LegalEntityInfo(cnpj, idFinancialSupportAgreement, salic, idProofHash, BlockchainAccountState.WAITING_VALIDATION);
// Apaga o mapping do endereo antigo
legalEntitiesInfo[oldAddr].state = BlockchainAccountState.INVALIDATED_BY_CHANGE;
// Aponta mapping CNPJ e Subcredito para newAddr
cnpjFSAddr[cnpj][idFinancialSupportAgreement] = newAddr;
emit AccountChange(oldAddr, newAddr, cnpj, idFinancialSupportAgreement, salic, idProofHash);
}
function validateRegistryLegalEntity(address addr, string memory idProofHash) public {
require(isResponsibleForRegistryValidation(msg.sender), "Somente o responsvel pela validao pode validar contas");
require(legalEntitiesInfo[addr].state == BlockchainAccountState.WAITING_VALIDATION, "A conta precisa estar no estado Aguardando Validao");
require(keccak256(abi.encodePacked(legalEntitiesInfo[addr].idProofHash)) == keccak256(abi.encodePacked(idProofHash)), "O hash recebido diferente do esperado");
legalEntitiesInfo[addr].state = BlockchainAccountState.VALIDATED;
emit AccountValidation(addr, legalEntitiesInfo[addr].cnpj,
legalEntitiesInfo[addr].idFinancialSupportAgreement,
legalEntitiesInfo[addr].salic);
}
function invalidateRegistryLegalEntity(address addr) public {
require(isResponsibleForRegistryValidation(msg.sender), "Somente o responsvel pela validao pode invalidar contas");
require(!isReservedAccount(addr), "No possvel invalidar conta reservada");
legalEntitiesInfo[addr].state = BlockchainAccountState.INVALIDATED_BY_VALIDATOR;
emit AccountInvalidation(addr, legalEntitiesInfo[addr].cnpj,
legalEntitiesInfo[addr].idFinancialSupportAgreement,
legalEntitiesInfo[addr].salic);
}
function setResponsibleForSettlement(address rs) onlyOwner public {
responsibleForSettlement = rs;
}
function setResponsibleForRegistryValidation(address rs) onlyOwner public {
responsibleForRegistryValidation = rs;
}
function setResponsibleForDisbursement(address rs) onlyOwner public {
responsibleForDisbursement = rs;
}
function setRedemptionAddress(address rs) onlyOwner public {
redemptionAddress = rs;
}
function setTokenAddress(address rs) onlyOwner public {
tokenAddress = rs;
}
function enableChangeAccount (address rs) public {
require(isResponsibleForRegistryValidation(msg.sender), "Somente o responsvel pela validao pode habilitar a troca de conta");
legalEntitiesChangeAccount[rs] = true;
}
function isChangeAccountEnabled (address rs) view public returns (bool) {
return legalEntitiesChangeAccount[rs] == true;
}
function isTokenAddress() public view returns (bool) {
return tokenAddress == msg.sender;
}
function isResponsibleForSettlement(address addr) view public returns (bool) {
return (addr == responsibleForSettlement);
}
function isResponsibleForRegistryValidation(address addr) view public returns (bool) {
return (addr == responsibleForRegistryValidation);
}
function isResponsibleForDisbursement(address addr) view public returns (bool) {
return (addr == responsibleForDisbursement);
}
function isRedemptionAddress(address addr) view public returns (bool) {
return (addr == redemptionAddress);
}
function isReservedAccount(address addr) view public returns (bool) {
if (isOwner(addr) || isResponsibleForSettlement(addr)
|| isResponsibleForRegistryValidation(addr)
|| isResponsibleForDisbursement(addr)
|| isRedemptionAddress(addr)) {
return true;
}
return false;
}
function isOwner(address addr) view public returns (bool) {
return owner()==addr;
}
function isSupplier(address addr) view public returns (bool) {
if (isReservedAccount(addr))
return false;
if (isAvailableAccount(addr))
return false;
return legalEntitiesInfo[addr].idFinancialSupportAgreement == 0;
}
function isValidatedSupplier (address addr) view public returns (bool) {
return isSupplier(addr) && (legalEntitiesInfo[addr].state == BlockchainAccountState.VALIDATED);
}
function isClient (address addr) view public returns (bool) {
if (isReservedAccount(addr)) {
return false;
}
return legalEntitiesInfo[addr].idFinancialSupportAgreement != 0;
}
function isValidatedClient (address addr) view public returns (bool) {
return isClient(addr) && (legalEntitiesInfo[addr].state == BlockchainAccountState.VALIDATED);
}
function isAvailableAccount(address addr) view public returns (bool) {
if (isReservedAccount(addr)) {
return false;
}
return legalEntitiesInfo[addr].state == BlockchainAccountState.AVAILABLE;
}
function isWaitingValidationAccount(address addr) view public returns (bool) {
return legalEntitiesInfo[addr].state == BlockchainAccountState.WAITING_VALIDATION;
}
function isValidatedAccount(address addr) view public returns (bool) {
return legalEntitiesInfo[addr].state == BlockchainAccountState.VALIDATED;
}
function isInvalidatedByValidatorAccount(address addr) view public returns (bool) {
return legalEntitiesInfo[addr].state == BlockchainAccountState.INVALIDATED_BY_VALIDATOR;
}
function isInvalidatedByChangeAccount(address addr) view public returns (bool) {
return legalEntitiesInfo[addr].state == BlockchainAccountState.INVALIDATED_BY_CHANGE;
}
function getResponsibleForSettlement() view public returns (address) {
return responsibleForSettlement;
}
function getResponsibleForRegistryValidation() view public returns (address) {
return responsibleForRegistryValidation;
}
function getResponsibleForDisbursement() view public returns (address) {
return responsibleForDisbursement;
}
function getRedemptionAddress() view public returns (address) {
return redemptionAddress;
}
function getCNPJ(address addr) view public returns (uint64) {
return legalEntitiesInfo[addr].cnpj;
}
function getIdLegalFinancialAgreement(address addr) view public returns (uint64) {
return legalEntitiesInfo[addr].idFinancialSupportAgreement;
}
function getLegalEntityInfo (address addr) view public returns (uint64, uint64, uint32, string memory, uint, address) {
return (legalEntitiesInfo[addr].cnpj, legalEntitiesInfo[addr].idFinancialSupportAgreement,
legalEntitiesInfo[addr].salic, legalEntitiesInfo[addr].idProofHash, (uint) (legalEntitiesInfo[addr].state),
addr);
}
function getBlockchainAccount(uint64 cnpj, uint64 idFinancialSupportAgreement) view public returns (address) {
return cnpjFSAddr[cnpj][idFinancialSupportAgreement];
}
function getLegalEntityInfoByCNPJ (uint64 cnpj, uint64 idFinancialSupportAgreement)
view public returns (uint64, uint64, uint32, string memory, uint, address) {
address addr = getBlockchainAccount(cnpj,idFinancialSupportAgreement);
return getLegalEntityInfo (addr);
}
function getAccountState(address addr) view public returns (int) {
if (isReservedAccount(addr)) {
return 100;
}
else {
return ((int) (legalEntitiesInfo[addr].state));
}
}
function isValidHash(string memory str) pure public returns (bool) {
bytes memory b = bytes(str);
if(b.length != 64) return false;
for (uint i=0; i<64; i++) {
if (b[i] < "0") return false;
if (b[i] > "9" && b[i] <"a") return false;
if (b[i] > "f") return false;
}
return true;
}
}
| 134,045 | 10,771 |
fec0d39083c034400350212ab64f03878c6e1617bedac37a5f04e406ccc55dd1
| 12,697 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Integer_overflow_and_underflow/Sol/buggy_7.sol
| 3,819 | 12,646 |
pragma solidity 0.4.25;
contract Ownable
{
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);
}
bool private stopped;
function bug_intou36(uint8 p_intou36) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou36; // overflow bug //Integer_overflow_and_underflow bug
}
address private _owner;
function bug_intou35() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
address private _master;
function bug_intou15() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
event Stopped();
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;
}
event Started();
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);
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function bug_intou12(uint8 p_intou12) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou12; // overflow bug //Integer_overflow_and_underflow bug
}
event MasterRoleTransferred(address indexed previousMaster, address indexed newMaster);
constructor () internal
{
stopped = false;
_owner = msg.sender;
_master = msg.sender;
emit OwnershipTransferred(address(0), _owner);
emit MasterRoleTransferred(address(0), _master);
}
function bug_intou32(uint8 p_intou32) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou32; // overflow bug //Integer_overflow_and_underflow bug
}
function owner() public view returns (address)
{
return _owner;
}
function bug_intou31() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function master() public view returns (address)
{
return _master;
}
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;
}
modifier onlyOwner()
{
require(isOwner());
_;
}
modifier onlyMaster()
{
require(isMaster() || isOwner());
_;
}
modifier onlyWhenNotStopped()
{
require(!isStopped());
_;
}
function isOwner() public view returns (bool)
{
return msg.sender == _owner;
}
function bug_intou3() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function isMaster() public view returns (bool)
{
return msg.sender == _master;
}
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 transferOwnership(address newOwner) external onlyOwner
{
_transferOwnership(newOwner);
}
function bug_intou28(uint8 p_intou28) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou28; // overflow bug //Integer_overflow_and_underflow bug
}
function transferMasterRole(address newMaster) external onlyOwner
{
_transferMasterRole(newMaster);
}
function bug_intou27() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function isStopped() public view returns (bool)
{
return stopped;
}
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 stop() public onlyOwner
{
_stop();
}
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);
}
function start() public onlyOwner
{
_start();
}
function bug_intou24(uint8 p_intou24) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou24; // overflow bug //Integer_overflow_and_underflow bug
}
function _transferOwnership(address newOwner) internal
{
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function bug_intou23() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function _transferMasterRole(address newMaster) internal
{
require(newMaster != address(0));
emit MasterRoleTransferred(_master, newMaster);
_master = newMaster;
}
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 _stop() internal
{
emit Stopped();
stopped = true;
}
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 _start() internal
{
emit Started();
stopped = false;
}
function bug_intou20(uint8 p_intou20) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou20; // overflow bug //Integer_overflow_and_underflow bug
}
}
contract AccountWallet is Ownable
{
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;
}
mapping(string => string) private btc;
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);
}
mapping(string => address) private eth;
function bug_intou11() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
event SetAddress(string account, string btcAddress, address ethAddress);
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 UpdateAddress(string from, string to);
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 DeleteAddress(string account);
function version() external pure returns(string memory)
{
return '1.0.0';
}
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 getAddress(string account) external view returns (string memory, address)
{
return (btc[account], eth[account]);
}
function bug_intou19() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function setAddress(string account, string btcAddress, address ethAddress) external onlyMaster onlyWhenNotStopped
{
require(bytes(account).length > 0);
btc[account] = btcAddress;
eth[account] = ethAddress;
emit SetAddress(account, btcAddress, ethAddress);
}
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 updateAccount(string from, string to) external onlyMaster onlyWhenNotStopped
{
require(bytes(from).length > 0);
require(bytes(to).length > 0);
btc[to] = btc[from];
eth[to] = eth[from];
btc[from] = '';
eth[from] = address(0);
emit UpdateAddress(from, to);
}
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 deleteAccount(string account) external onlyMaster onlyWhenNotStopped
{
require(bytes(account).length > 0);
btc[account] = '';
eth[account] = address(0);
emit DeleteAddress(account);
}
function bug_intou16(uint8 p_intou16) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou16; // overflow bug //Integer_overflow_and_underflow bug
}
}
| 223,765 | 10,772 |
a7b4485968bb0efd6219898870545a5718e36c2611b59467969cefd4de52a329
| 30,954 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f2/F2cD3e2A9Ac9CE47F9fe4A099Fe112a792CEffea_HubPresale.sol
| 4,025 | 15,540 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using 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 HubPresale is Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
struct UserInfo {
uint256 amount; // Amount DAI deposited by user
uint256 debt; // total HUB claimed
bool claimed; // True if a user has claimed HUB
}
address public MultiSignAddress = 0x39b662c836B9ddb0186A190Cbb63AEd5562951cb;
// Tokens to raise (DAI) and for offer (pHUB) which can be swapped for (HUB)
IERC20 public DAI; // for user deposits
IERC20 public HUB;
uint256 public price = 2 * 1e18; // 2 DAI per pHUB
uint256 public cap = 1000 * 1e18; // 1000 DAI cap per user
uint256 public totalRaisedDAI; // total DAI raised by sale
uint256 public totalDebt; // total pHUB and thus HUB owed to users
bool public started; // true when sale is started
bool public ended; // true when sale is ended
bool public claimable; // true when sale is claimable
bool public contractPaused; // circuit breaker
mapping(address => UserInfo) public userInfo;
event Deposit(address indexed who, uint256 amount);
event Withdraw(address token, address indexed who, uint256 amount);
event Mint(address token, address indexed who, uint256 amount);
event SaleStarted(uint256 block);
event SaleEnded(uint256 block);
event ClaimUnlocked(uint256 block);
event ClaimPresaleUnlocked(uint256 block);
event AdminWithdrawal(address token, uint256 amount);
constructor(address _HUB,
address _DAI) {
require(_HUB != address(0));
HUB = IERC20(_HUB);
require(_DAI != address(0));
DAI = IERC20(_DAI);
}
/
function setHUB(address _HUB) external onlyOwner {
require(_HUB != address(0));
HUB = IERC20(_HUB);
}
function setPrice(uint256 _price) external onlyOwner {
require(!started, "Sale has already started");
price = _price;
}
function setCap(uint256 _cap) external onlyOwner {
require(!started, "Sale has already started");
cap = _cap;
}
// @notice Starts the sale
function start() external onlyOwner {
require(!started, "Sale has already started");
started = true;
emit SaleStarted(block.number);
}
// @notice Ends the sale
function end() external onlyOwner {
require(started, "Sale has not started");
require(!ended, "Sale has already ended");
ended = true;
emit SaleEnded(block.number);
}
// @notice lets users claim HUB
// @dev send sufficient HUB before calling
function claimUnlock() external onlyOwner {
require(ended, "Sale has not ended");
require(!claimable, "Claim has already been unlocked");
require(HUB.balanceOf(address(this)) >= totalDebt, 'not enough HUB in contract');
claimable = true;
emit ClaimUnlocked(block.number);
}
// @notice lets owner pause contract
function togglePause() external onlyOwner returns (bool){
contractPaused = !contractPaused;
return contractPaused;
}
function adminWithdraw(address _token, uint256 _amount) external onlyOwner {
IERC20(_token).safeTransfer(address(msg.sender), _amount);
emit AdminWithdrawal(_token, _amount);
}
function deposit(uint256 _amount) external checkIfPaused {
require(started, 'Sale has not started');
require(!ended, 'Sale has ended');
UserInfo storage user = userInfo[msg.sender];
require(cap >= user.amount.add(_amount), 'new amount above user limit');
user.amount = user.amount.add(_amount);
totalRaisedDAI = totalRaisedDAI.add(_amount);
uint256 payout = _amount.mul(1e18).div(price).div(1e9);
user.debt = user.debt.add(payout);
totalDebt = totalDebt.add(payout);
DAI.safeTransferFrom(msg.sender, MultiSignAddress, _amount);
emit Deposit(msg.sender, _amount);
}
function claim() external checkIfPaused {
require(claimable, 'HUB is not yet claimable');
UserInfo storage user = userInfo[msg.sender];
require(!user.claimed, 'User already claimed HUB');
require(user.debt > 0, 'User should have unclaimed HUB');
require(HUB.balanceOf(address(this)) >= user.debt, 'Not enough HUB tokens on contract');
uint256 amount = user.debt;
HUB.safeTransfer(msg.sender, amount);
user.debt = 0;
user.claimed = true;
totalDebt = totalDebt.sub(amount);
emit Withdraw(address(HUB), msg.sender, amount);
}
// @notice set the home address
function setMultiSignAddress(address _MultiSignAddress) external onlyOwner {
require(_MultiSignAddress != address(0));
MultiSignAddress = _MultiSignAddress;
}
// @notice it checks a users DAI allocation remaining
function getUserRemainingAllocation(address _user) external view returns (uint256) {
UserInfo memory user = userInfo[_user];
return cap.sub(user.amount);
}
}
| 83,925 | 10,773 |
4f6b7589f72c961de474f7e2e1a79039698fbc0b8cfef2b88bbc156fec9fde53
| 18,018 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/42/423392A67265E06dc0a00DfC931749b672EEDb67_Distributor.sol
| 3,975 | 15,701 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable ATN;
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 _atn, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_atn != address(0));
ATN = _atn;
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(ATN).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
});
}
}
| 102,402 | 10,774 |
52def3947ae058390f4a7e5183710e64a3b5421214ed64e50c148939d10cff15
| 9,711 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/Dependency_of_timestamp/Sol/buggy_26.sol
| 2,910 | 9,658 |
pragma solidity ^0.5.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;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract UBBCToken is IERC20 {
using SafeMath for uint256;
function bug_tmstmp25() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
mapping (address => uint256) private _balances;
function bug_tmstmp24 () public payable {
uint pastBlockTime_tmstmp24; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp24); // only 1 transaction per block //bug //Dependency_of_timestamp bug
pastBlockTime_tmstmp24 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
mapping (address => mapping (address => uint256)) private _allowances;
address winner_tmstmp23;
function play_tmstmp23(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp23 = msg.sender;}}
uint256 private _totalSupply;
address winner_tmstmp22;
function play_tmstmp22(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp22 = msg.sender;}}
string private _name;
function bug_tmstmp21() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
string private _symbol;
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 //Dependency_of_timestamp bug
pastBlockTime_tmstmp20 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
uint8 private _decimals;
constructor() public {
_name = "UBBC Token";
_symbol = "UBBC";
_decimals = 18;
_totalSupply = 260000000 ether;
_balances[0x0e475cd2c1f8222868cf85B4f97D7EB70fB3ffD3] = _totalSupply;
}
address winner_tmstmp2;
function play_tmstmp2(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp2 = msg.sender;}}
uint256 bugv_tmstmp2 = block.timestamp;
event Transfer(address sender, address to, uint256 value);
uint256 bugv_tmstmp1 = block.timestamp;
event Approval(address owner, address spender, uint256 value);
function name() public view returns (string memory) {
return _name;
}
address winner_tmstmp19;
function play_tmstmp19(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp19 = msg.sender;}}
function symbol() public view returns (string memory) {
return _symbol;
}
address winner_tmstmp18;
function play_tmstmp18(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp18 = msg.sender;}}
function decimals() public view returns (uint8) {
return _decimals;
}
function bug_tmstmp17() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function bug_tmstmp16 () public payable {
uint pastBlockTime_tmstmp16; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp16); // only 1 transaction per block //bug //Dependency_of_timestamp bug
pastBlockTime_tmstmp16 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
address winner_tmstmp15;
function play_tmstmp15(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp15 = msg.sender;}}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
address winner_tmstmp14;
function play_tmstmp14(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp14 = msg.sender;}}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function bug_tmstmp13() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
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 //Dependency_of_timestamp bug
pastBlockTime_tmstmp12 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
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;
}
address winner_tmstmp11;
function play_tmstmp11(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp11 = msg.sender;}}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
address winner_tmstmp10;
function play_tmstmp10(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp10 = msg.sender;}}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function bug_tmstmp1() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
uint256 bugv_tmstmp5 = block.timestamp;
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);
}
uint256 bugv_tmstmp4 = block.timestamp;
function () payable external{
revert();
}
uint256 bugv_tmstmp3 = block.timestamp;
}
| 224,081 | 10,775 |
c67750ddbbd7f4ef2a626b0d604bfa1d1908a79868262ce47c7de17d4e90576d
| 17,887 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x518e5a711cf84666b98dddb00a0d4a0a6c59955e.sol
| 3,438 | 13,701 |
pragma solidity ^0.4.3;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "Sender not authorised.");
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
uint256 public totalSupply;
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 ERC677 is ERC20 {
function transferAndCall(address to, uint value, bytes data) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
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;
}
}
library itmap {
struct entry {
// Equal to the index of the key of this item in keys, plus 1.
uint keyIndex;
uint value;
}
struct itmap {
mapping(uint => entry) data;
uint[] keys;
}
function insert(itmap storage self, uint key, uint value) internal returns (bool replaced) {
entry storage e = self.data[key];
e.value = value;
if (e.keyIndex > 0) {
return true;
} else {
e.keyIndex = ++self.keys.length;
self.keys[e.keyIndex - 1] = key;
return false;
}
}
function remove(itmap storage self, uint key) internal returns (bool success) {
entry storage e = self.data[key];
if (e.keyIndex == 0)
return false;
if (e.keyIndex < self.keys.length) {
// Move an existing element into the vacated key slot.
self.data[self.keys[self.keys.length - 1]].keyIndex = e.keyIndex;
self.keys[e.keyIndex - 1] = self.keys[self.keys.length - 1];
self.keys.length -= 1;
delete self.data[key];
return true;
}
}
function contains(itmap storage self, uint key) internal view returns (bool exists) {
return self.data[key].keyIndex > 0;
}
function size(itmap storage self) internal view returns (uint) {
return self.keys.length;
}
function get(itmap storage self, uint key) internal view returns (uint) {
return self.data[key].value;
}
function getKey(itmap storage self, uint idx) internal view returns (uint) {
return self.keys[idx];
}
}
contract PoolOwners is Ownable {
using SafeMath for uint256;
using itmap for itmap.itmap;
struct Owner {
uint256 key;
uint256 percentage;
uint256 shareTokens;
mapping(address => uint256) balance;
}
mapping(address => Owner) public owners;
struct Distribution {
address token;
uint256 amount;
uint256 owners;
uint256 claimed;
mapping(address => bool) claimedAddresses;
}
mapping(uint256 => Distribution) public distributions;
mapping(address => uint256) public tokenBalance;
mapping(address => uint256) public totalReturned;
mapping(address => bool) private whitelist;
itmap.itmap ownerMap;
uint256 public totalContributed = 0;
uint256 public totalOwners = 0;
uint256 public totalDistributions = 0;
bool public distributionActive = false;
uint256 public distributionMinimum = 20 ether;
uint256 public precisionMinimum = 0.04 ether;
bool public locked = false;
address public wallet;
bool private contributionStarted = false;
uint256 private valuation = 4000 ether;
uint256 private hardCap = 1000 ether;
event Contribution(address indexed sender, uint256 share, uint256 amount);
event ClaimedTokens(address indexed owner, address indexed token, uint256 amount, uint256 claimedStakers, uint256 distributionId);
event TokenDistributionActive(address indexed token, uint256 amount, uint256 distributionId, uint256 amountOfOwners);
event TokenWithdrawal(address indexed token, address indexed owner, uint256 amount);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner, uint256 amount);
event TokenDistributionComplete(address indexed token, uint256 amountOfOwners);
modifier onlyWhitelisted() {
require(whitelist[msg.sender]);
_;
}
constructor(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
}
function() public payable {
require(contributionStarted, "Contribution phase hasn't started");
require(whitelist[msg.sender], "You are not whitelisted");
contribute(msg.sender, msg.value);
wallet.transfer(msg.value);
}
function setContribution(address _sender, uint256 _amount) public onlyOwner() { contribute(_sender, _amount); }
function contribute(address _sender, uint256 _amount) private {
require(!locked, "Crowdsale period over, contribution is locked");
require(!distributionActive, "Cannot contribute when distribution is active");
require(_amount >= precisionMinimum, "Amount needs to be above the minimum contribution");
require(hardCap >= _amount, "Your contribution is greater than the hard cap");
require(_amount % precisionMinimum == 0, "Your amount isn't divisible by the minimum precision");
require(hardCap >= totalContributed.add(_amount), "Your contribution would cause the total to exceed the hardcap");
totalContributed = totalContributed.add(_amount);
uint256 share = percent(_amount, valuation, 5);
Owner storage o = owners[_sender];
if (o.percentage != 0) { // Existing owner
o.shareTokens = o.shareTokens.add(_amount);
o.percentage = o.percentage.add(share);
} else { // New owner
o.key = totalOwners;
require(ownerMap.insert(o.key, uint(_sender)) == false);
totalOwners += 1;
o.shareTokens = _amount;
o.percentage = share;
}
if (!whitelist[msg.sender]) {
whitelist[msg.sender] = true;
}
emit Contribution(_sender, share, _amount);
}
function whitelistWallet(address _owner) external onlyOwner() {
require(!locked, "Can't whitelist when the contract is locked");
require(_owner != address(0), "Empty address");
whitelist[_owner] = true;
}
function startContribution() external onlyOwner() {
require(!contributionStarted, "Contribution has started");
contributionStarted = true;
}
function setOwnerShare(address _owner, uint256 _value) public onlyOwner() {
require(!locked, "Can't manually set shares, it's locked");
require(!distributionActive, "Cannot set owners share when distribution is active");
Owner storage o = owners[_owner];
if (o.shareTokens == 0) {
whitelist[_owner] = true;
require(ownerMap.insert(totalOwners, uint(_owner)) == false);
o.key = totalOwners;
totalOwners += 1;
}
o.shareTokens = _value;
o.percentage = percent(_value, valuation, 5);
}
function sendOwnership(address _receiver, uint256 _amount) public onlyWhitelisted() {
Owner storage o = owners[msg.sender];
Owner storage r = owners[_receiver];
require(o.shareTokens > 0, "You don't have any ownership");
require(o.shareTokens >= _amount, "The amount exceeds what you have");
require(!distributionActive, "Distribution cannot be active when sending ownership");
require(_amount % precisionMinimum == 0, "Your amount isn't divisible by the minimum precision amount");
o.shareTokens = o.shareTokens.sub(_amount);
if (o.shareTokens == 0) {
o.percentage = 0;
require(ownerMap.remove(o.key) == true);
} else {
o.percentage = percent(o.shareTokens, valuation, 5);
}
if (r.shareTokens == 0) {
if (!whitelist[_receiver]) {
r.key = totalOwners;
whitelist[_receiver] = true;
totalOwners += 1;
}
require(ownerMap.insert(r.key, uint(_receiver)) == false);
}
r.shareTokens = r.shareTokens.add(_amount);
r.percentage = r.percentage.add(percent(_amount, valuation, 5));
emit OwnershipTransferred(msg.sender, _receiver, _amount);
}
function lockShares() public onlyOwner() {
require(!locked, "Shares already locked");
locked = true;
}
function distributeTokens(address _token) public onlyWhitelisted() {
require(!distributionActive, "Distribution is already active");
distributionActive = true;
ERC677 erc677 = ERC677(_token);
uint256 currentBalance = erc677.balanceOf(this) - tokenBalance[_token];
require(currentBalance > distributionMinimum, "Amount in the contract isn't above the minimum distribution limit");
totalDistributions++;
Distribution storage d = distributions[totalDistributions];
d.owners = ownerMap.size();
d.amount = currentBalance;
d.token = _token;
d.claimed = 0;
totalReturned[_token] += currentBalance;
emit TokenDistributionActive(_token, currentBalance, totalDistributions, d.owners);
}
function claimTokens(address _owner) public {
Owner storage o = owners[_owner];
Distribution storage d = distributions[totalDistributions];
require(o.shareTokens > 0, "You need to have a share to claim tokens");
require(distributionActive, "Distribution isn't active");
require(!d.claimedAddresses[_owner], "Tokens already claimed for this address");
address token = d.token;
uint256 tokenAmount = d.amount.mul(o.percentage).div(100000);
o.balance[token] = o.balance[token].add(tokenAmount);
tokenBalance[token] = tokenBalance[token].add(tokenAmount);
d.claimed++;
d.claimedAddresses[_owner] = true;
emit ClaimedTokens(_owner, token, tokenAmount, d.claimed, totalDistributions);
if (d.claimed == d.owners) {
distributionActive = false;
emit TokenDistributionComplete(token, totalOwners);
}
}
function withdrawTokens(address _token, uint256 _amount) public {
require(_amount > 0, "You have requested for 0 tokens to be withdrawn");
Owner storage o = owners[msg.sender];
Distribution storage d = distributions[totalDistributions];
if (distributionActive && !d.claimedAddresses[msg.sender]) {
claimTokens(msg.sender);
}
require(o.balance[_token] >= _amount, "Amount requested is higher than your balance");
o.balance[_token] = o.balance[_token].sub(_amount);
tokenBalance[_token] = tokenBalance[_token].sub(_amount);
ERC677 erc677 = ERC677(_token);
require(erc677.transfer(msg.sender, _amount) == true);
emit TokenWithdrawal(_token, msg.sender, _amount);
}
function setDistributionMinimum(uint256 _minimum) public onlyOwner() {
distributionMinimum = _minimum;
}
function setEthWallet(address _wallet) public onlyOwner() {
wallet = _wallet;
}
function isWhitelisted(address _owner) public view returns (bool) {
return whitelist[_owner];
}
function getOwnerBalance(address _token) public view returns (uint256) {
Owner storage o = owners[msg.sender];
return o.balance[_token];
}
function getOwner(address _owner) public view returns (uint256, uint256, uint256) {
Owner storage o = owners[_owner];
return (o.key, o.shareTokens, o.percentage);
}
function getCurrentOwners() public view returns (uint) {
return ownerMap.size();
}
function getOwnerAddress(uint _key) public view returns (address) {
return address(ownerMap.get(_key));
}
function hasClaimed(address _owner, uint256 _dId) public view returns (bool) {
Distribution storage d = distributions[_dId];
return d.claimedAddresses[_owner];
}
function percent(uint numerator, uint denominator, uint precision) private pure returns (uint quotient) {
uint _numerator = numerator * 10 ** (precision+1);
uint _quotient = ((_numerator / denominator) + 5) / 10;
return (_quotient);
}
}
| 191,294 | 10,776 |
f46e2defa37487f06a54401b985256a842f7e8a482c3ee50dedb02bd5970cdbc
| 24,911 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/PHRP-0xf1cac3dae6ba2c818e880c1e5b0081f575483434.sol
| 2,645 | 9,964 |
// SPDX-License-Identifier: NOLC
pragma solidity ^0.6.12;
//
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
//
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
//
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal virtual {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
//
abstract contract ERC20Burnable is Context, ERC20 {
using SafeMath for uint256;
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
}
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 MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor() public {
_addMinter(msg.sender);
}
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 onlyMinter {
_addMinter(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 PHRP is MinterRole, ERC20Burnable {
constructor()
ERC20("PHRP", "PHRP")
public
{
}
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
_mint(account, amount);
return true;
}
}
| 206,897 | 10,777 |
f4e2683443bfefef9bac6c8d877ebbaf90282e7ab7d4361705f2479d7f547226
| 13,373 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
experiments/ge-sc-data/source_code/arithmetic/clean_60_buggy_curated_0/buggy_29.sol
| 3,309 | 11,113 |
pragma solidity >=0.5.11;
// * Gods Unchained Raffle Token Exchange
//
// * Version 1.0
//
// * A dedicated contract for listing (selling) and buying raffle tokens.
//
// * https://gu.cards
contract ERC20Interface {
function transferFrom(address from, address to, uint tokens) public returns (bool success);
function bug_intou7() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
}
contract IERC20Interface {
function allowance(address owner, address spender) external view returns (uint256);
function bug_intou23() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
function balanceOf(address account) external view returns (uint256);
mapping(address => uint) balances_intou14;
function transfer_intou14(address _to, uint _value) public returns (bool) {
require(balances_intou14[msg.sender] - _value >= 0); //bug
balances_intou14[msg.sender] -= _value; //bug
balances_intou14[_to] += _value; //bug
return true;
}
}
contract RaffleToken is ERC20Interface, IERC20Interface {}
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 RaffleTokenExchange {
using SafeMath for uint256;
//////// V A R I A B L E S
//
// The raffle token contract
//
RaffleToken constant public raffleContract = RaffleToken(0x0C8cDC16973E88FAb31DD0FCB844DdF0e1056dE2);
//
// In case the exchange is paused.
//
function bug_intou19() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
bool public paused;
//
// Standard contract ownership.
//
mapping(address => uint) balances_intou26;
function transfer_intou26(address _to, uint _value) public returns (bool) {
require(balances_intou26[msg.sender] - _value >= 0); //bug
balances_intou26[msg.sender] -= _value; //bug
balances_intou26[_to] += _value; //bug
return true;
}
address payable public owner;
//
// Next id for the next listing
//
function bug_intou20(uint8 p_intou20) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou20; // overflow bug
}
uint256 public nextListingId;
//
// All raffle token listings mapped by id
//
function bug_intou32(uint8 p_intou32) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou32; // overflow bug
}
mapping (uint256 => Listing) public listingsById;
//
// All purchases
//
mapping(address => uint) balances_intou38;
function transfer_intou38(address _to, uint _value) public returns (bool) {
require(balances_intou38[msg.sender] - _value >= 0); //bug
balances_intou38[msg.sender] -= _value; //bug
balances_intou38[_to] += _value; //bug
return true;
}
mapping (uint256 => Purchase) public purchasesById;
//
// Next id for the next purche
//
function bug_intou4(uint8 p_intou4) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou4; // overflow bug
}
uint256 public nextPurchaseId;
//////// S T R U C T S
//
// A listing of raffle tokens
//
struct Listing {
//
// price per token (in wei).
//
uint256 pricePerToken;
//
//
// How many tokens? (Original Amount)
//
uint256 initialAmount;
//
// How many tokens left? (Maybe altered due to partial sales)
//
uint256 amountLeft;
//
// Listed by whom?
//
address payable seller;
//
// Active/Inactive listing?
//
bool active;
}
//
// A purchase of raffle tokens
//
struct Purchase {
//
// How many tokens?
//
uint256 totalAmount;
//
// total price payed
//
uint256 totalAmountPayed;
//
// When did the purchase happen?
//
uint256 timestamp;
}
//////// EVENTS
//
//
//
function bug_intou27() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
event Listed(uint256 id, uint256 pricePerToken, uint256 initialAmount, address seller);
function bug_intou31() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
event Canceled(uint256 id);
mapping(address => uint) public lockTime_intou13;
function increaseLockTime_intou13(uint _secondsToIncrease) public {
lockTime_intou13[msg.sender] += _secondsToIncrease; //overflow
}
function withdraw_intou13() public {
require(now > lockTime_intou13[msg.sender]);
uint transferValue_intou13 = 10;
msg.sender.transfer(transferValue_intou13);
}
event Purchased(uint256 id, uint256 totalAmount, uint256 totalAmountPayed, uint256 timestamp);
//////// M O D I F I E R S
//
// Invokable only by contract owner.
//
modifier onlyContractOwner {
require(msg.sender == owner, "Function called by non-owner.");
_;
}
//
// Invokable only if exchange is not paused.
//
modifier onlyUnpaused {
require(paused == false, "Exchange is paused.");
_;
}
//////// C O N S T R U C T O R
//
constructor() public {
owner = msg.sender;
nextListingId = 916;
nextPurchaseId = 344;
}
mapping(address => uint) balances_intou30;
function transfer_intou30(address _to, uint _value) public returns (bool) {
require(balances_intou30[msg.sender] - _value >= 0); //bug
balances_intou30[msg.sender] -= _value; //bug
balances_intou30[_to] += _value; //bug
return true;
}
//////// F U N C T I O N S
//
// buyRaffle
//
function buyRaffle(uint256[] calldata amounts, uint256[] calldata listingIds) payable external onlyUnpaused {
require(amounts.length == listingIds.length, "You have to provide amounts for every single listing!");
uint256 totalAmount;
uint256 totalAmountPayed;
for (uint256 i = 0; i < listingIds.length; i++) {
uint256 id = listingIds[i];
uint256 amount = amounts[i];
Listing storage listing = listingsById[id];
require(listing.active, "Listing is not active anymore!");
listing.amountLeft = listing.amountLeft.sub(amount);
require(listing.amountLeft >= 0, "Amount left needs to be higher than 0.");
if(listing.amountLeft == 0) { listing.active = false; }
uint256 amountToPay = listing.pricePerToken * amount;
listing.seller.transfer(amountToPay);
totalAmountPayed = totalAmountPayed.add(amountToPay);
totalAmount = totalAmount.add(amount);
require(raffleContract.transferFrom(listing.seller, msg.sender, amount), 'Token transfer failed!');
}
require(totalAmountPayed <= msg.value, 'Overpayed!');
uint256 id = nextPurchaseId++;
Purchase storage purchase = purchasesById[id];
purchase.totalAmount = totalAmount;
purchase.totalAmountPayed = totalAmountPayed;
purchase.timestamp = now;
emit Purchased(id, totalAmount, totalAmountPayed, now);
}
function bug_intou8(uint8 p_intou8) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou8; // overflow bug
}
//
// Add listing
//
function addListing(uint256 initialAmount, uint256 pricePerToken) external onlyUnpaused {
require(raffleContract.balanceOf(msg.sender) >= initialAmount, "Amount to sell is higher than balance!");
require(raffleContract.allowance(msg.sender, address(this)) >= initialAmount, "Allowance is to small (increase allowance)!");
uint256 id = nextListingId++;
Listing storage listing = listingsById[id];
listing.initialAmount = initialAmount;
listing.amountLeft = initialAmount;
listing.pricePerToken = pricePerToken;
listing.seller = msg.sender;
listing.active = true;
emit Listed(id, listing.pricePerToken, listing.initialAmount, listing.seller);
}
function bug_intou39() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
//
// Cancel listing
//
function cancelListing(uint256 id) external {
Listing storage listing = listingsById[id];
require(listing.active, "This listing was turned inactive already!");
require(listing.seller == msg.sender || owner == msg.sender, "Only the listing owner or the contract owner can cancel the listing!");
listing.active = false;
emit Canceled(id);
}
function bug_intou36(uint8 p_intou36) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou36; // overflow bug
}
//
// Set paused
//
function setPaused(bool value) external onlyContractOwner {
paused = value;
}
function bug_intou35() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
//
// Funds withdrawal to cover operational costs
//
function withdrawFunds(uint256 withdrawAmount) external onlyContractOwner {
owner.transfer(withdrawAmount);
}
function bug_intou40(uint8 p_intou40) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou40; // overflow bug
}
//
// Contract may be destroyed only when there is nothing else going on.
// All funds are transferred to contract owner.
//
function kill() external onlyContractOwner {
selfdestruct(owner);
}
mapping(address => uint) public lockTime_intou33;
function increaseLockTime_intou33(uint _secondsToIncrease) public {
lockTime_intou33[msg.sender] += _secondsToIncrease; //overflow
}
function withdraw_intou33() public {
require(now > lockTime_intou33[msg.sender]);
uint transferValue_intou33 = 10;
msg.sender.transfer(transferValue_intou33);
}
}
| 132,940 | 10,778 |
eae0ad55d96dfb25ed24481e3df5e844b8157becd96860df08ded158ec2547ea
| 28,670 |
.sol
|
Solidity
| false |
507660474
|
tintinweb/smart-contract-sanctuary-celo
|
81b52aac6adcf513ef4af86806a71db3704a5958
|
contracts/mainnet/0e/0edc96c7ab57620fe11eaa245bfc24725888cf15_GatewayMint.sol
| 4,094 | 15,598 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
}
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;
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address, RecoverError) {
// the valid range for s in (301): 0 < s < secp256k1n 2 + 1, and for v in (302): v {27, 28}. Most
//
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
interface ICappedMintableBurnableERC20 {
function decimals() external view returns (uint8);
function cap() external view returns (uint256);
function minter(address) external view returns (bool);
function mint(address, uint256) external;
function burn(uint256) external;
function burnFrom(address, uint256) external;
}
contract GatewayMint is OwnableUpgradeable, ReentrancyGuard {
using SafeMath for uint256;
address public verifyAuthority;
mapping(address => uint256) public minterCaps;
mapping(address => bool) public whitelisted;
/// @notice Each signature can only be seen once.
mapping(bytes32 => bool) public status;
address public token;
bool public paused;
uint256 public mininumOutAmount;
uint256 public mininumInAmount;
event InNetwork(uint256 networkId, bytes32 txHash, address account, uint256 amount);
event OutNetwork(uint256 networkId, address account, uint256 amount);
function initialize(address _token, uint256 _mininumOutAmount, uint256 _mininumInAmount) public initializer {
OwnableUpgradeable.__Ownable_init();
token = _token;
mininumOutAmount = _mininumOutAmount;
mininumInAmount = _mininumInAmount;
paused = false;
}
modifier notContract() {
if (!whitelisted[msg.sender]) {
uint256 size;
address addr = msg.sender;
assembly {
size := extcodesize(addr)
}
require(size == 0, "contract not allowed");
require(tx.origin == msg.sender, "contract not allowed");
}
_;
}
modifier checkMinterCap(uint256 _amount) {
require(minterCaps[msg.sender] >= _amount, "!minter");
_;
}
modifier whenNotPaused() {
require(!paused, "contract paused");
_;
}
function setVerifyAuthority(address _verifyAuthority) external onlyOwner {
verifyAuthority = _verifyAuthority;
}
function setPause(bool _paused) external onlyOwner {
paused = _paused;
}
function setWhitelisted(address _account, bool _whitelisted) external nonReentrant onlyOwner {
whitelisted[_account] = _whitelisted;
}
function setMinterCap(address _minter, uint256 _cap) external onlyOwner {
minterCaps[_minter] = _cap;
}
function setMinimumOutAmount(uint256 _mininumOutAmount) external onlyOwner {
mininumOutAmount = _mininumOutAmount;
}
function setMinimumInAmount(uint256 _mininumInAmount) external onlyOwner {
mininumInAmount = _mininumInAmount;
}
function getSigner(bytes32 _signedMessageHash, bytes memory _sig) public pure returns (address) {
return ECDSA.recover(_signedMessageHash, _sig);
}
/// @notice verifySignature checks the the provided signature matches the provided
/// parameters.
function verifySignature(bytes32 _signedMessageHash, bytes memory _sig) public view returns (bool) {
return verifyAuthority == ECDSA.recover(_signedMessageHash, _sig);
}
/// @notice hashForSignature hashes the parameters so that they can be signed.
function hashForSignature(uint256 _networkId, bytes32 _txHash, uint256 _amount, address _receiver, bytes32 _nHash) public view returns (bytes32) {
return keccak256(abi.encode(_networkId, _txHash, _amount, address(token), _receiver, _nHash));
}
function getEthSignedMessageHash(bytes32 _messageHash) public pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _messageHash));
}
function outNetwork(uint256 _networkId,
address _receiver,
uint256 _amount) public whenNotPaused {
require(_amount >= mininumOutAmount, "_amount less than mininumOutAmount");
ICappedMintableBurnableERC20(token).burnFrom(msg.sender, _amount);
emit OutNetwork(_networkId, _receiver, _amount);
}
function inNetwork(uint256 _networkId,
bytes32 _txHash,
address _receiver,
uint256 _amount,
bytes32 _nHash,
bytes memory _sig) public whenNotPaused checkMinterCap(_amount) notContract {
require(_amount >= mininumInAmount, "_amount less than mininumInAmount");
// Verify signature
bytes32 signedMessage = hashForSignature(_networkId, _txHash, _amount, _receiver, _nHash);
require(status[signedMessage] == false, "Gateway: nonce hash already spent");
bytes32 ethSignedMessageHash = getEthSignedMessageHash(signedMessage);
require(verifySignature(ethSignedMessageHash, _sig), "Gateway: invalid sig");
minterCaps[msg.sender] = minterCaps[msg.sender].sub(_amount);
status[signedMessage] = true;
ICappedMintableBurnableERC20(token).mint(_receiver, _amount);
emit InNetwork(_networkId, _txHash, _receiver, _amount);
}
}
| 269,406 | 10,779 |
6c5f64d5e5223a44bae001e09b489922537381beff6558b5627e01bd06faf159
| 11,555 |
.sol
|
Solidity
| false |
429467347
|
makerdao/dss-cron
|
4d0ba3b10e4ba0334f5c2c88b22711af4e76bb54
|
src/tests/mocks/VatMock.sol
| 3,683 | 11,494 |
// SPDX-License-Identifier: AGPL-3.0-or-later
/// 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.13;
contract VatMock {
// --- Data ---
mapping (address => uint256) public wards;
mapping(address => mapping (address => uint256)) public can;
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 => uint256)) 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; // Active Flag
// --- Events ---
event Rely(address indexed usr);
event Deny(address indexed usr);
event Init(bytes32 indexed ilk);
event File(bytes32 indexed what, uint256 data);
event File(bytes32 indexed ilk, bytes32 indexed what, uint256 data);
event Cage();
event Hope(address indexed from, address indexed to);
event Nope(address indexed from, address indexed to);
event Slip(bytes32 indexed ilk, address indexed usr, int256 wad);
event Flux(bytes32 indexed ilk, address indexed src, address indexed dst, uint256 wad);
event Move(address indexed src, address indexed dst, uint256 rad);
event Frob(bytes32 indexed i, address indexed u, address v, address w, int256 dink, int256 dart);
event Fork(bytes32 indexed ilk, address indexed src, address indexed dst, int256 dink, int256 dart);
event Grab(bytes32 indexed i, address indexed u, address v, address w, int256 dink, int256 dart);
event Heal(address indexed u, uint256 rad);
event Suck(address indexed u, address indexed v, uint256 rad);
event Fold(bytes32 indexed i, address indexed u, int256 rate);
modifier auth {
require(wards[msg.sender] == 1, "Vat/not-authorized");
_;
}
function wish(address bit, address usr) internal view returns (bool) {
return either(bit == usr, can[bit][usr] == 1);
}
// --- Init ---
constructor() {
wards[msg.sender] = 1;
live = 1;
emit Rely(msg.sender);
}
// --- Math ---
string private constant ARITHMETIC_ERROR = string(abi.encodeWithSignature("Panic(uint256)", 0x11));
function _add(uint256 x, int256 y) internal pure returns (uint256 z) {
unchecked {
z = x + uint256(y);
}
require(y >= 0 || z <= x, ARITHMETIC_ERROR);
require(y <= 0 || z >= x, ARITHMETIC_ERROR);
}
function _sub(uint256 x, int256 y) internal pure returns (uint256 z) {
unchecked {
z = x - uint256(y);
}
require(y <= 0 || z <= x, ARITHMETIC_ERROR);
require(y >= 0 || z >= x, ARITHMETIC_ERROR);
}
function _int256(uint256 x) internal pure returns (int256 y) {
require((y = int256(x)) >= 0, ARITHMETIC_ERROR);
}
// --- Administration ---
function rely(address usr) external auth {
require(live == 1, "Vat/not-live");
wards[usr] = 1;
emit Rely(usr);
}
function deny(address usr) external auth {
require(live == 1, "Vat/not-live");
wards[usr] = 0;
emit Deny(usr);
}
function init(bytes32 ilk) external auth {
require(ilks[ilk].rate == 0, "Vat/ilk-already-init");
ilks[ilk].rate = 10 ** 27;
emit Init(ilk);
}
function file(bytes32 what, uint256 data) external auth {
require(live == 1, "Vat/not-live");
if (what == "Line") Line = data;
else revert("Vat/file-unrecognized-param");
emit File(what, data);
}
function file(bytes32 ilk, bytes32 what, uint256 data) external 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");
emit File(ilk, what, data);
}
function cage() external auth {
live = 0;
emit Cage();
}
// --- Structs getters ---
function Art(bytes32 ilk) external view returns (uint256 Art_) {
Art_ = ilks[ilk].Art;
}
function rate(bytes32 ilk) external view returns (uint256 rate_) {
rate_ = ilks[ilk].rate;
}
function spot(bytes32 ilk) external view returns (uint256 spot_) {
spot_ = ilks[ilk].spot;
}
function line(bytes32 ilk) external view returns (uint256 line_) {
line_ = ilks[ilk].line;
}
function dust(bytes32 ilk) external view returns (uint256 dust_) {
dust_ = ilks[ilk].dust;
}
function ink(bytes32 ilk, address urn) external view returns (uint256 ink_) {
ink_ = urns[ilk][urn].ink;
}
function art(bytes32 ilk, address urn) external view returns (uint256 art_) {
art_ = urns[ilk][urn].art;
}
// --- Allowance ---
function hope(address usr) external {
can[msg.sender][usr] = 1;
emit Hope(msg.sender, usr);
}
function nope(address usr) external {
can[msg.sender][usr] = 0;
emit Nope(msg.sender, usr);
}
// --- Fungibility ---
function slip(bytes32 ilk, address usr, int256 wad) external auth {
gem[ilk][usr] = _add(gem[ilk][usr], wad);
emit Slip(ilk, usr, wad);
}
function flux(bytes32 ilk, address src, address dst, uint256 wad) external {
require(wish(src, msg.sender), "Vat/not-allowed");
gem[ilk][src] = gem[ilk][src] - wad;
gem[ilk][dst] = gem[ilk][dst] + wad;
emit Flux(ilk, src, dst, wad);
}
function move(address src, address dst, uint256 rad) external {
require(wish(src, msg.sender), "Vat/not-allowed");
dai[src] = dai[src] - rad;
dai[dst] = dai[dst] + rad;
emit Move(src, dst, rad);
}
function either(bool x, bool y) internal pure returns (bool z) {
assembly{ z := or(x, y)}
}
function both(bool x, bool y) internal pure returns (bool z) {
assembly{ z := and(x, y)}
}
// --- CDP Manipulation ---
function frob(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external {
// system is live
require(live == 1, "Vat/not-live");
uint256 rate_ = ilks[i].rate;
// ilk has been initialised
require(rate_ != 0, "Vat/ilk-not-init");
Urn memory urn = urns[i][u];
urn.ink = _add(urn.ink, dink);
urn.art = _add(urn.art, dart);
uint256 Art_ = _add(ilks[i].Art, dart);
int256 dtab = _int256(rate_) * dart;
uint256 debt_ = _add(debt, dtab);
// either debt has decreased, or debt ceilings are not exceeded
require(either(dart <= 0, both(Art_ * rate_ <= ilks[i].line, debt_ <= Line)), "Vat/ceiling-exceeded");
uint256 tab = rate_ * urn.art;
// urn is either less risky than before, or it is safe
require(either(both(dart <= 0, dink >= 0), tab <= urn.ink * ilks[i].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 >= ilks[i].dust), "Vat/dust");
// update storage values
gem[i][v] = _sub(gem[i][v], dink);
dai[w] = _add(dai[w], dtab);
urns[i][u] = urn;
ilks[i].Art = Art_;
debt = debt_;
emit Frob(i, u, v, w, dink, dart);
}
// --- CDP Fungibility ---
function fork(bytes32 ilk, address src, address dst, int256 dink, int256 dart) external {
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);
uint256 utab = u.art * i.rate;
uint256 vtab = 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 <= u.ink * i.spot, "Vat/not-safe-src");
require(vtab <= 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");
emit Fork(ilk, src, dst, dink, dart);
}
// --- CDP Confiscation ---
function grab(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external 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);
int256 dtab = _int256(ilk.rate) * dart;
gem[i][v] = _sub(gem[i][v], dink);
sin[w] = _sub(sin[w], dtab);
vice = _sub(vice, dtab);
emit Grab(i, u, v, w, dink, dart);
}
// --- Settlement ---
function heal(uint256 rad) external {
address u = msg.sender;
sin[u] = sin[u] - rad;
dai[u] = dai[u] - rad;
vice = vice - rad;
debt = debt - rad;
emit Heal(msg.sender, rad);
}
function suck(address u, address v, uint256 rad) external auth {
sin[u] = sin[u] + rad;
dai[v] = dai[v] + rad;
vice = vice + rad;
debt = debt + rad;
emit Suck(u, v, rad);
}
// --- Rates ---
function fold(bytes32 i, address u, int256 rate_) external auth {
require(live == 1, "Vat/not-live");
Ilk storage ilk = ilks[i];
ilk.rate = _add(ilk.rate, rate_);
int256 rad = _int256(ilk.Art) * rate_;
dai[u] = _add(dai[u], rad);
debt = _add(debt, rad);
emit Fold(i, u, rate_);
}
}
| 224,412 | 10,780 |
1802969c65d9b7ad8ff8720480a378dfbb80eea31caed5fb4fd0b5ac6ef7609c
| 34,812 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x006b4425ba57148466c0c54af1c484348a14a8a4.sol
| 4,744 | 20,086 |
pragma solidity ^0.4.15;
// File: contracts\infrastructure\ITokenRetreiver.sol
contract ITokenRetreiver {
function retreiveTokens(address _tokenContract);
}
// File: contracts\integration\wings\IWingsAdapter.sol
contract IWingsAdapter {
function totalCollected() constant returns (uint);
}
// File: contracts\infrastructure\modifier\Owned.sol
contract Owned {
// The address of the account that is the current owner
address internal owner;
function Owned() {
owner = msg.sender;
}
modifier only_owner() {
require(msg.sender == owner);
_;
}
}
// File: contracts\source\token\IToken.sol
contract IToken {
function totalSupply() constant returns (uint);
function balanceOf(address _owner) constant returns (uint);
function transfer(address _to, uint _value) returns (bool);
function transferFrom(address _from, address _to, uint _value) returns (bool);
function approve(address _spender, uint _value) returns (bool);
function allowance(address _owner, address _spender) constant returns (uint);
}
// File: contracts\source\token\IManagedToken.sol
contract IManagedToken is IToken {
function isLocked() constant returns (bool);
function unlock() returns (bool);
function issue(address _to, uint _value) returns (bool);
}
// File: contracts\source\crowdsale\ICrowdsale.sol
contract ICrowdsale {
function isInPresalePhase() constant returns (bool);
function hasBalance(address _beneficiary, uint _releaseDate) constant returns (bool);
function balanceOf(address _owner) constant returns (uint);
function ethBalanceOf(address _owner) constant returns (uint);
function refundableEthBalanceOf(address _owner) constant returns (uint);
function getRate(uint _phase, uint _volume) constant returns (uint);
function toTokens(uint _wei, uint _rate) constant returns (uint);
function withdrawTokens();
function withdrawEther();
function refund();
function () payable;
}
// File: contracts\source\crowdsale\Crowdsale.sol
contract Crowdsale is ICrowdsale, Owned {
enum Stages {
Deploying,
Deployed,
InProgress,
Ended
}
struct Balance {
uint eth;
uint tokens;
uint index;
}
struct Percentage {
uint eth;
uint tokens;
bool overwriteReleaseDate;
uint fixedReleaseDate;
uint index;
}
struct Payout {
uint percentage;
uint vestingPeriod;
}
struct Phase {
uint rate;
uint end;
uint bonusReleaseDate;
bool useVolumeMultiplier;
}
struct VolumeMultiplier {
uint rateMultiplier;
uint bonusReleaseDateMultiplier;
}
// Crowdsale details
uint public baseRate;
uint public minAmount;
uint public maxAmount;
uint public minAcceptedAmount;
uint public minAmountPresale;
uint public maxAmountPresale;
uint public minAcceptedAmountPresale;
// Company address
address public beneficiary;
// Denominators
uint internal percentageDenominator;
uint internal tokenDenominator;
// Crowdsale state
uint public start;
uint public presaleEnd;
uint public crowdsaleEnd;
uint public raised;
uint public allocatedEth;
uint public allocatedTokens;
Stages public stage = Stages.Deploying;
// Token contract
IManagedToken public token;
// Invested balances
mapping (address => uint) private balances;
// Alocated balances
mapping (address => mapping(uint => Balance)) private allocated;
mapping(address => uint[]) private allocatedIndex;
// Stakeholders
mapping (address => Percentage) private stakeholderPercentages;
address[] private stakeholderPercentagesIndex;
Payout[] private stakeholdersPayouts;
// Crowdsale phases
Phase[] private phases;
// Volume multipliers
mapping (uint => VolumeMultiplier) private volumeMultipliers;
uint[] private volumeMultiplierThresholds;
modifier at_stage(Stages _stage) {
require(stage == _stage);
_;
}
modifier only_after(uint _time) {
require(now > crowdsaleEnd + _time);
_;
}
modifier only_after_crowdsale() {
require(now > crowdsaleEnd);
_;
}
modifier only_beneficiary() {
require(beneficiary == msg.sender);
_;
}
function isAcceptedContributor(address _contributor) internal constant returns (bool);
function Crowdsale(uint _start, address _token, uint _tokenDenominator, uint _percentageDenominator, uint _minAmount, uint _maxAmount, uint _minAcceptedAmount, uint _minAmountPresale, uint _maxAmountPresale, uint _minAcceptedAmountPresale) {
token = IManagedToken(_token);
tokenDenominator = _tokenDenominator;
percentageDenominator = _percentageDenominator;
start = _start;
minAmount = _minAmount;
maxAmount = _maxAmount;
minAcceptedAmount = _minAcceptedAmount;
minAmountPresale = _minAmountPresale;
maxAmountPresale = _maxAmountPresale;
minAcceptedAmountPresale = _minAcceptedAmountPresale;
}
function setupPhases(uint _baseRate, uint[] _phaseRates, uint[] _phasePeriods, uint[] _phaseBonusLockupPeriods, bool[] _phaseUsesVolumeMultiplier) public only_owner at_stage(Stages.Deploying) {
baseRate = _baseRate;
presaleEnd = start + _phasePeriods[0]; // First phase is expected to be the presale phase
crowdsaleEnd = start; // Plus the sum of the rate phases
for (uint i = 0; i < _phaseRates.length; i++) {
crowdsaleEnd += _phasePeriods[i];
phases.push(Phase(_phaseRates[i], crowdsaleEnd, 0, _phaseUsesVolumeMultiplier[i]));
}
for (uint ii = 0; ii < _phaseRates.length; ii++) {
if (_phaseBonusLockupPeriods[ii] > 0) {
phases[ii].bonusReleaseDate = crowdsaleEnd + _phaseBonusLockupPeriods[ii];
}
}
}
function setupStakeholders(address[] _stakeholders, uint[] _stakeholderEthPercentages, uint[] _stakeholderTokenPercentages, bool[] _stakeholderTokenPayoutOverwriteReleaseDates, uint[] _stakeholderTokenPayoutFixedReleaseDates, uint[] _stakeholderTokenPayoutPercentages, uint[] _stakeholderTokenPayoutVestingPeriods) public only_owner at_stage(Stages.Deploying) {
beneficiary = _stakeholders[0]; // First stakeholder is expected to be the beneficiary
for (uint i = 0; i < _stakeholders.length; i++) {
stakeholderPercentagesIndex.push(_stakeholders[i]);
stakeholderPercentages[_stakeholders[i]] = Percentage(_stakeholderEthPercentages[i],
_stakeholderTokenPercentages[i],
_stakeholderTokenPayoutOverwriteReleaseDates[i],
_stakeholderTokenPayoutFixedReleaseDates[i], i);
}
// Percentages add up to 100
for (uint ii = 0; ii < _stakeholderTokenPayoutPercentages.length; ii++) {
stakeholdersPayouts.push(Payout(_stakeholderTokenPayoutPercentages[ii], _stakeholderTokenPayoutVestingPeriods[ii]));
}
}
function setupVolumeMultipliers(uint[] _volumeMultiplierRates, uint[] _volumeMultiplierLockupPeriods, uint[] _volumeMultiplierThresholds) public only_owner at_stage(Stages.Deploying) {
require(phases.length > 0);
volumeMultiplierThresholds = _volumeMultiplierThresholds;
for (uint i = 0; i < volumeMultiplierThresholds.length; i++) {
volumeMultipliers[volumeMultiplierThresholds[i]] = VolumeMultiplier(_volumeMultiplierRates[i], _volumeMultiplierLockupPeriods[i]);
}
}
function deploy() public only_owner at_stage(Stages.Deploying) {
require(phases.length > 0);
require(stakeholderPercentagesIndex.length > 0);
stage = Stages.Deployed;
}
function confirmBeneficiary() public only_beneficiary at_stage(Stages.Deployed) {
stage = Stages.InProgress;
}
function isInPresalePhase() public constant returns (bool) {
return stage == Stages.InProgress && now >= start && now <= presaleEnd;
}
function hasBalance(address _beneficiary, uint _releaseDate) public constant returns (bool) {
return allocatedIndex[_beneficiary].length > 0 && _releaseDate == allocatedIndex[_beneficiary][allocated[_beneficiary][_releaseDate].index];
}
function balanceOf(address _owner) public constant returns (uint) {
uint sum = 0;
for (uint i = 0; i < allocatedIndex[_owner].length; i++) {
sum += allocated[_owner][allocatedIndex[_owner][i]].tokens;
}
return sum;
}
function ethBalanceOf(address _owner) public constant returns (uint) {
uint sum = 0;
for (uint i = 0; i < allocatedIndex[_owner].length; i++) {
sum += allocated[_owner][allocatedIndex[_owner][i]].eth;
}
return sum;
}
function refundableEthBalanceOf(address _owner) public constant returns (uint) {
return now > crowdsaleEnd && raised < minAmount ? balances[_owner] : 0;
}
function getCurrentPhase() public constant returns (uint) {
for (uint i = 0; i < phases.length; i++) {
if (now <= phases[i].end) {
return i;
break;
}
}
return phases.length; // Does not exist
}
function getRate(uint _phase, uint _volume) public constant returns (uint) {
uint rate = 0;
if (stage == Stages.InProgress && now >= start) {
Phase storage phase = phases[_phase];
rate = phase.rate;
// Find volume multiplier
if (phase.useVolumeMultiplier && volumeMultiplierThresholds.length > 0 && _volume >= volumeMultiplierThresholds[0]) {
for (uint i = volumeMultiplierThresholds.length; i > 0; i--) {
if (_volume >= volumeMultiplierThresholds[i - 1]) {
VolumeMultiplier storage multiplier = volumeMultipliers[volumeMultiplierThresholds[i - 1]];
rate += phase.rate * multiplier.rateMultiplier / percentageDenominator;
break;
}
}
}
}
return rate;
}
function getDistributionData(uint _phase, uint _volume) internal constant returns (uint[], uint[]) {
Phase storage phase = phases[_phase];
uint remainingVolume = _volume;
bool usingMultiplier = false;
uint[] memory volumes = new uint[](1);
uint[] memory releaseDates = new uint[](1);
// Find volume multipliers
if (phase.useVolumeMultiplier && volumeMultiplierThresholds.length > 0 && _volume >= volumeMultiplierThresholds[0]) {
uint phaseReleasePeriod = phase.bonusReleaseDate - crowdsaleEnd;
for (uint i = volumeMultiplierThresholds.length; i > 0; i--) {
if (_volume >= volumeMultiplierThresholds[i - 1]) {
if (!usingMultiplier) {
volumes = new uint[](i + 1);
releaseDates = new uint[](i + 1);
usingMultiplier = true;
}
VolumeMultiplier storage multiplier = volumeMultipliers[volumeMultiplierThresholds[i - 1]];
uint releaseDate = phase.bonusReleaseDate + phaseReleasePeriod * multiplier.bonusReleaseDateMultiplier / percentageDenominator;
uint volume = remainingVolume - volumeMultiplierThresholds[i - 1];
// Store increment
volumes[i] = volume;
releaseDates[i] = releaseDate;
remainingVolume -= volume;
}
}
}
// Store increment
volumes[0] = remainingVolume;
releaseDates[0] = phase.bonusReleaseDate;
return (volumes, releaseDates);
}
function toTokens(uint _wei, uint _rate) public constant returns (uint) {
return _wei * _rate * tokenDenominator / 1 ether;
}
function endCrowdsale() public at_stage(Stages.InProgress) {
require(now > crowdsaleEnd || raised >= maxAmount);
require(raised >= minAmount);
stage = Stages.Ended;
// Unlock token
if (!token.unlock()) {
revert();
}
// Allocate tokens (no allocation can be done after this period)
uint totalTokenSupply = token.totalSupply() + allocatedTokens;
for (uint i = 0; i < stakeholdersPayouts.length; i++) {
Payout storage p = stakeholdersPayouts[i];
_allocateStakeholdersTokens(totalTokenSupply * p.percentage / percentageDenominator, now + p.vestingPeriod);
}
// Allocate remaining ETH
_allocateStakeholdersEth(this.balance - allocatedEth, 0);
}
function withdrawTokens() public {
uint tokensToSend = 0;
for (uint i = 0; i < allocatedIndex[msg.sender].length; i++) {
uint releaseDate = allocatedIndex[msg.sender][i];
if (releaseDate <= now) {
Balance storage b = allocated[msg.sender][releaseDate];
tokensToSend += b.tokens;
b.tokens = 0;
}
}
if (tokensToSend > 0) {
allocatedTokens -= tokensToSend;
if (!token.issue(msg.sender, tokensToSend)) {
revert();
}
}
}
function withdrawEther() public {
uint ethToSend = 0;
for (uint i = 0; i < allocatedIndex[msg.sender].length; i++) {
uint releaseDate = allocatedIndex[msg.sender][i];
if (releaseDate <= now) {
Balance storage b = allocated[msg.sender][releaseDate];
ethToSend += b.eth;
b.eth = 0;
}
}
if (ethToSend > 0) {
allocatedEth -= ethToSend;
if (!msg.sender.send(ethToSend)) {
revert();
}
}
}
function refund() public only_after_crowdsale at_stage(Stages.InProgress) {
require(raised < minAmount);
uint receivedAmount = balances[msg.sender];
balances[msg.sender] = 0;
if (receivedAmount > 0 && !msg.sender.send(receivedAmount)) {
balances[msg.sender] = receivedAmount;
}
}
function destroy() public only_beneficiary only_after(2 years) {
selfdestruct(beneficiary);
}
function contribute() public payable {
_handleTransaction(msg.sender, msg.value);
}
function () payable {
require(msg.sender == tx.origin);
_handleTransaction(msg.sender, msg.value);
}
function _handleTransaction(address _sender, uint _received) private at_stage(Stages.InProgress) {
// Crowdsale is active
require(now >= start && now <= crowdsaleEnd);
// Whitelist check
require(isAcceptedContributor(_sender));
// When in presale phase
bool presalePhase = isInPresalePhase();
require(!presalePhase || _received >= minAcceptedAmountPresale);
require(!presalePhase || raised < maxAmountPresale);
// When in ico phase
require(presalePhase || _received >= minAcceptedAmount);
require(presalePhase || raised >= minAmountPresale);
require(presalePhase || raised < maxAmount);
uint acceptedAmount;
if (presalePhase && raised + _received > maxAmountPresale) {
acceptedAmount = maxAmountPresale - raised;
} else if (raised + _received > maxAmount) {
acceptedAmount = maxAmount - raised;
} else {
acceptedAmount = _received;
}
raised += acceptedAmount;
if (presalePhase) {
// During the presale phase - Non refundable
_allocateStakeholdersEth(acceptedAmount, 0);
} else {
// During the ICO phase - 100% refundable
balances[_sender] += acceptedAmount;
}
// Distribute tokens
uint tokensToIssue = 0;
uint phase = getCurrentPhase();
var rate = getRate(phase, acceptedAmount);
var (volumes, releaseDates) = getDistributionData(phase, acceptedAmount);
// Allocate tokens
for (uint i = 0; i < volumes.length; i++) {
var tokensAtCurrentRate = toTokens(volumes[i], rate);
if (rate > baseRate && releaseDates[i] > now) {
uint bonusTokens = tokensAtCurrentRate / rate * (rate - baseRate);
_allocateTokens(_sender, bonusTokens, releaseDates[i]);
tokensToIssue += tokensAtCurrentRate - bonusTokens;
} else {
tokensToIssue += tokensAtCurrentRate;
}
}
// Issue tokens
if (tokensToIssue > 0 && !token.issue(_sender, tokensToIssue)) {
revert();
}
// Refund due to max cap hit
if (_received - acceptedAmount > 0 && !_sender.send(_received - acceptedAmount)) {
revert();
}
}
function _allocateEth(address _beneficiary, uint _amount, uint _releaseDate) private {
if (hasBalance(_beneficiary, _releaseDate)) {
allocated[_beneficiary][_releaseDate].eth += _amount;
} else {
allocated[_beneficiary][_releaseDate] = Balance(_amount, 0, allocatedIndex[_beneficiary].push(_releaseDate) - 1);
}
allocatedEth += _amount;
}
function _allocateTokens(address _beneficiary, uint _amount, uint _releaseDate) private {
if (hasBalance(_beneficiary, _releaseDate)) {
allocated[_beneficiary][_releaseDate].tokens += _amount;
} else {
allocated[_beneficiary][_releaseDate] = Balance(0, _amount, allocatedIndex[_beneficiary].push(_releaseDate) - 1);
}
allocatedTokens += _amount;
}
function _allocateStakeholdersEth(uint _amount, uint _releaseDate) private {
for (uint i = 0; i < stakeholderPercentagesIndex.length; i++) {
Percentage storage p = stakeholderPercentages[stakeholderPercentagesIndex[i]];
if (p.eth > 0) {
_allocateEth(stakeholderPercentagesIndex[i], _amount * p.eth / percentageDenominator, _releaseDate);
}
}
}
function _allocateStakeholdersTokens(uint _amount, uint _releaseDate) private {
for (uint i = 0; i < stakeholderPercentagesIndex.length; i++) {
Percentage storage p = stakeholderPercentages[stakeholderPercentagesIndex[i]];
if (p.tokens > 0) {
_allocateTokens(stakeholderPercentagesIndex[i],
_amount * p.tokens / percentageDenominator,
p.overwriteReleaseDate ? p.fixedReleaseDate : _releaseDate);
}
}
}
}
// File: contracts\source\NUCrowdsale.sol
contract NUCrowdsale is Crowdsale, ITokenRetreiver, IWingsAdapter {
function NUCrowdsale(uint _start, address _token, uint _tokenDenominator, uint _percentageDenominator, uint _minAmount, uint _maxAmount, uint _minAcceptedAmount, uint _minAmountPresale, uint _maxAmountPresale, uint _minAcceptedAmountPresale)
Crowdsale(_start, _token, _tokenDenominator, _percentageDenominator, _minAmount, _maxAmount, _minAcceptedAmount, _minAmountPresale, _maxAmountPresale, _minAcceptedAmountPresale)
{
}
function totalCollected() public constant returns (uint) {
return raised;
}
function isAcceptedContributor(address _contributor) internal constant returns (bool) {
return _contributor != address(0x0);
}
function retreiveTokens(address _tokenContract) public only_beneficiary {
IToken tokenInstance = IToken(_tokenContract);
// Retreive tokens from our token contract
ITokenRetreiver(token).retreiveTokens(_tokenContract);
// Retreive tokens from crowdsale contract
uint tokenBalance = tokenInstance.balanceOf(this);
if (tokenBalance > 0) {
tokenInstance.transfer(beneficiary, tokenBalance);
}
}
}
| 217,735 | 10,781 |
ec6bf7d8455e96bc27983d57fd737fedff8ae3c586d8e6fe69eea05c3c9d5a23
| 28,408 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TQ/TQZhRZcXXxYGSPk5jHWf1ynUG495ML5jwV_CHXStake.sol
| 5,345 | 20,765 |
//SourceUnit: CHXStake.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library 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 ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
contract CHXStake is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public FHToken;
address public USDT;
address public mk;
uint256 public DURATION = 30 days;
uint256 public CANCARRY = 25 days;
uint256 private _decimals = 6;
uint256 public initreward = 136 * 10 ** _decimals;
uint256 public totalReferralReward = 0;
uint256 public usdtOne = 100 * 10 ** _decimals;
uint256 public usdtFive = 500 * 10 ** _decimals;
uint256 public usdtThousand = 1000 * 10 ** _decimals;
uint256 public usdtFiveThousand = 5000 * 10 ** _decimals;
address public _destroyAddress = address(0x000000000000000000000000000000000000dEaD);
uint256 public _totalSupply;
mapping(address => uint256) private _balances;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
mapping(address => address) internal _parents;
mapping(address => address[]) _mychilders;
mapping(address => uint256) public _userTime;
event RewardAdded(uint256 reward);
event BindingParents(address indexed user, address inviter);
event Staked(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event TradingPooladded(address ctyToken, uint256 dyAmount);
event SetTradingPooladded(uint256 pid,address ctyToken, uint256 dyAmount);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
PoolInfo[] public poolInfo;
struct PoolInfo {
address ctyToken;
uint256 dyAmount;
}
constructor (address _mk, address _FHToken, address _ctyToken, uint256 _dyAmount, address _USDT) {
mk = _mk;
FHToken = _FHToken;
USDT = _USDT;
poolInfo.push(PoolInfo({
ctyToken: _ctyToken,
dyAmount: _dyAmount
}));
rewardRate = initreward.div(DURATION);
lastUpdateTime = block.timestamp;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function getMyChilders(address user) public view returns (address[] memory) {
return _mychilders[user];
}
function getParent(address user) public view returns (address) {
return _parents[user];
}
function getChildresAmount(address user) public view returns (uint256) {
if (_parents[user] != address(0)) {
address parent = _parents[user];
uint256 Level_1 = earned(_parents[user]);
uint256 Level_2 = earned(_parents[parent]);
return Level_1.add(Level_2);
} else {
return 0;
}
}
function getUserTime(address user) public view returns (uint256) {
return _userTime[user];
}
function bindParent(address parent) public returns (bool) {
require(_parents[msg.sender] == address(0), "Already bind");
require(parent != address(0), "ERROR parent");
require(parent != msg.sender, "ERROR parent");
require(_parents[parent] != address(0));
_parents[msg.sender] = parent;
_mychilders[parent].push(msg.sender);
emit BindingParents(msg.sender, parent);
return true;
}
function setParentByAdmin(address user, address parent) public onlyOwner returns (bool) {
require(_parents[user] == address(0), "Already bind");
_parents[user] = parent;
_mychilders[parent].push(user);
return true;
}
function setRewardRate(uint256 _init) updateReward(msg.sender) external onlyOwner{
initreward = _init * 10 ** _decimals;
rewardRate = initreward.div(DURATION);
}
function addTradingPool(address _ctyToken,uint256 _dyAmount) public onlyOwner {
poolInfo.push(PoolInfo({
ctyToken: _ctyToken,
dyAmount: _dyAmount
}));
emit TradingPooladded(_ctyToken, _dyAmount);
}
function setTradingPool(uint256 _pid,address _ctyToken,uint256 _dyAmount) public onlyOwner {
poolInfo[_pid].ctyToken = _ctyToken;
poolInfo[_pid].dyAmount = _dyAmount;
emit SetTradingPooladded(_pid, _ctyToken, _dyAmount);
}
function lastTimeRewardApplicable() public view returns (uint256) {
return block.timestamp;
}
function rewardPerToken() public view returns (uint256) {
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e6)
.div(_totalSupply));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e6)
.add(rewards[account]);
}
function deposit(uint256 pid, uint256 amount) public updateReward(msg.sender) nonReentrant {
require(amount > 0, "Cannot stake 0");
require(amount == usdtOne || amount == usdtFive || amount == usdtThousand || amount == usdtFiveThousand, "Cannot");
address NctyToken = poolInfo[pid].ctyToken;
uint256 NdyAmount = poolInfo[pid].dyAmount;
if (amount == usdtOne) {
IERC20(NctyToken).safeTransferFrom(msg.sender, _destroyAddress, NdyAmount);
} else if (amount == usdtFive) {
IERC20(NctyToken).safeTransferFrom(msg.sender, _destroyAddress, NdyAmount.mul(5));
} else if (amount == usdtThousand) {
IERC20(NctyToken).safeTransferFrom(msg.sender, _destroyAddress, NdyAmount.mul(10));
} else if (amount == usdtFiveThousand) {
IERC20(NctyToken).safeTransferFrom(msg.sender, _destroyAddress, NdyAmount.mul(50));
} else {
require(false, "Invalid input");
}
if (_userTime[msg.sender] == 0) {
_userTime[msg.sender] = block.timestamp;
}
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
IERC20(USDT).safeTransferFrom(msg.sender, mk, amount);
}
function exit() external {
getReward();
}
function getReward() public updateReward(msg.sender) nonReentrant {
uint256 time = _userTime[msg.sender] + CANCARRY;
require(block.timestamp > time, "getReward no start");
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
address parent = _parents[address(msg.sender)];
if (parent != address(0) && parent != address(this)) {
uint256 projectfee = reward.mul(10).div(100);
address Level_2_address = _parents[parent];
if (Level_2_address != address(0)) {
uint256 Level_2_Fee = reward.mul(5).div(100);
safeTransfer(Level_2_address, Level_2_Fee);
}
safeTransfer(parent, projectfee);
safeTransfer(msg.sender, reward);
} else {
safeTransfer(msg.sender, reward);
}
emit RewardPaid(msg.sender, reward);
totalReferralReward = totalReferralReward.add(reward);
}
}
function safeTransfer(address _to, uint256 _amount) internal {
uint256 tokenBalance = IERC20(FHToken).balanceOf(address(this));
require(_amount <= tokenBalance, "no token");
IERC20(FHToken).transfer(_to, _amount);
}
function donateDust(address addr, uint256 amount) external onlyOwner {
TransferHelper.safeTransfer(addr, _msgSender(), amount);
}
function donateEthDust(uint256 amount) external onlyOwner {
TransferHelper.safeTransferETH(_msgSender(), amount);
}
}
| 289,758 | 10,782 |
17847aadb05cca69338bea65c8eaf0efae4f169bd88337c8a83da4a0e9f215e5
| 22,800 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TG/TGCHwdS6gV44YGaZJYH5vu5d8Z6JvFGZei_TronSip.sol
| 6,059 | 21,539 |
//SourceUnit: tronsip_finaly.sol
pragma solidity ^0.5.4;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
uint256 maxDailyInterest;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
uint256 level4RefCount;
uint256 level5RefCount;
}
}
contract Ownable {
address public owner;
event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit onOwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract TronSip is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant DEVELOPER_ENTRY_RATE = 50; //per thousand
uint256 private constant ADMIN_ENTRY_RATE = 50;
uint256 private constant REFERENCE_RATE = 120;
uint256 private constant DEVELOPER_EXIT_RATE = 100; //per thousand
uint256 private constant ADMIN_EXIT_RATE = 50;
uint256 public constant REFERENCE_LEVEL1_RATE = 50;
uint256 public constant REFERENCE_LEVEL2_RATE = 30;
uint256 public constant REFERENCE_LEVEL3_RATE = 20;
uint256 public constant REFERENCE_LEVEL4_RATE = 10;
uint256 public constant REFERENCE_LEVEL5_RATE = 10;
uint256 public constant MINIMUM = 10000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 1234; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
address payable private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function checkIn() public {
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function setReferenceAccount(address payable _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(10,300*60*60*24,10)); //300 days
investmentPlans_.push(Objects.Plan(20, 90*60*60*24,20)); //90 days
investmentPlans_.push(Objects.Plan(30, 50*60*60*24,30)); //50 days
investmentPlans_.push(Objects.Plan(40, 32*60*60*24,40)); //32 days
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
uint256[] memory maxInterests = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
maxInterests[i] = plan.maxDailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
maxInterests,
terms);
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory, uint256[] memory,uint256,uint256,uint256) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.planCount,
currentDividends,
newDividends,
investor.level3RefCount,
investor.level4RefCount,
investor.level5RefCount);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory,uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory interests = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
newDividends[i] = 0;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
isExpireds[i] = true;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
}else{
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
newDividends,
interests,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _ref5 = uid2Investor[_ref4].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
if (_ref4 >= REFERRER_CODE) {
uid2Investor[_ref4].level4RefCount = uid2Investor[_ref4].level4RefCount.add(1);
}
if (_ref5 >= REFERRER_CODE) {
uid2Investor[_ref5].level5RefCount = uid2Investor[_ref5].level5RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_ENTRY_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(ADMIN_ENTRY_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate , plan.maxDailyInterest);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_EXIT_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(ADMIN_EXIT_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
msg.sender.transfer(withdrawalAmount.sub(developerPercentage.add(marketingPercentage)));
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start , uint256 _maxDailyInterest) private pure returns (uint256) {
uint256 numberOfDays = (_now - _start) / INTEREST_CYCLE ;
uint256 result = 0;
uint256 index = 0;
if(numberOfDays > 0){
uint256 secondsLeft = (_now - _start);
for (index; index < numberOfDays; index++) {
if(_dailyInterestRate + index <= _maxDailyInterest){
secondsLeft -= INTEREST_CYCLE;
result += (_amount * (_dailyInterestRate + index) / 1000 * INTEREST_CYCLE) / (60*60*24);
}
else{
break;
}
}
result += (_amount * (_dailyInterestRate + index) / 1000 * secondsLeft) / (60*60*24);
return result;
}else{
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _ref4 = uid2Investor[_ref3].referrer;
uint256 _ref5 = uid2Investor[_ref4].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
if (_ref4 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL4_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref4].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref4].availableReferrerEarnings);
}
if (_ref5 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL5_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref5].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref5].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 299,322 | 10,783 |
b90812654a47e2c79346211497d44f98fa59832968224deaf9a68ef2650feab0
| 29,632 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/50/50bF91f757F4F1F48E42b88819bBb5D9a336a82e_StrategySpiritFarm.sol
| 4,607 | 17,810 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.7;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// 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 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 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 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 ILiquidDepositor {
function treasury() external view returns (address);
}
interface IMasterChef {
function BONUS_MULTIPLIER() external view returns (uint256);
function add(uint256 _allocPoint,
address _lpToken,
bool _withUpdate) external;
function bonusEndBlock() external view returns (uint256);
function deposit(uint256 _pid, uint256 _amount) external;
function dev(address _devaddr) external;
function devFundDivRate() external view returns (uint256);
function devaddr() external view returns (address);
function emergencyWithdraw(uint256 _pid) external;
function getMultiplier(uint256 _from, uint256 _to)
external
view
returns (uint256);
function massUpdatePools() external;
function owner() external view returns (address);
function pendingPickle(uint256 _pid, address _user)
external
view
returns (uint256);
function pendingReward(uint256 _pid, address _user)
external
view
returns (uint256);
function pending(uint256 _pid, address _user)
external
view
returns (uint256);
function pickle() external view returns (address);
function picklePerBlock() external view returns (uint256);
function poolInfo(uint256)
external
view
returns (address lpToken,
uint256 allocPoint,
uint256 lastRewardBlock,
uint256 accPicklePerShare);
function poolLength() external view returns (uint256);
function renounceOwnership() external;
function set(uint256 _pid,
uint256 _allocPoint,
bool _withUpdate) external;
function setBonusEndBlock(uint256 _bonusEndBlock) external;
function setDevFundDivRate(uint256 _devFundDivRate) external;
function setPicklePerBlock(uint256 _picklePerBlock) external;
function startBlock() external view returns (uint256);
function totalAllocPoint() external view returns (uint256);
function transferOwnership(address newOwner) external;
function updatePool(uint256 _pid) external;
function userInfo(uint256, address)
external
view
returns (uint256 amount, uint256 rewardDebt);
function withdraw(uint256 _pid, uint256 _amount) external;
}
abstract contract StrategyBase {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
// Tokens
address public want;
// User accounts
address public governance;
address public depositor;
mapping(address => bool) public harvesters;
constructor(address _want,
address _depositor) public {
require(_want != address(0));
require(_depositor != address(0));
want = _want;
depositor = _depositor;
governance = msg.sender;
}
// **** Modifiers **** //
modifier onlyBenevolent {
require(harvesters[msg.sender] || msg.sender == governance || msg.sender == depositor);
_;
}
// **** Views **** //
function balanceOfWant() public view returns (uint256) {
return IERC20(want).balanceOf(address(this));
}
function balanceOfPool() public virtual view returns (uint256);
function balanceOf() public view returns (uint256) {
return balanceOfWant().add(balanceOfPool());
}
// **** Setters **** //
function whitelistHarvesters(address[] calldata _harvesters) external {
require(msg.sender == governance || harvesters[msg.sender], "not authorized");
for (uint i = 0; i < _harvesters.length; i ++) {
harvesters[_harvesters[i]] = true;
}
}
function revokeHarvesters(address[] calldata _harvesters) external {
require(msg.sender == governance, "not authorized");
for (uint i = 0; i < _harvesters.length; i ++) {
harvesters[_harvesters[i]] = false;
}
}
function setGovernance(address _governance) external {
require(msg.sender == governance, "!governance");
governance = _governance;
}
function setDepositor(address _depositor) external {
require(msg.sender == governance, "!governance");
depositor = _depositor;
}
// **** State mutations **** //
function deposit() public virtual;
// Controller only function for creating additional rewards from dust
function withdraw(IERC20 _asset) external onlyBenevolent returns (uint256 balance) {
require(msg.sender == governance, "!governance");
require(want != address(_asset), "want");
balance = _asset.balanceOf(address(this));
_asset.safeTransfer(depositor, balance);
}
// Withdraw partial funds
function withdraw(uint256 _amount) external returns (uint256) {
require(msg.sender == depositor, "!depositor");
uint256 _balance = IERC20(want).balanceOf(address(this));
if (_balance < _amount) {
_amount = _withdrawSome(_amount.sub(_balance));
_amount = _amount.add(_balance);
}
IERC20(want).safeTransfer(depositor, _amount);
return _amount;
}
// Withdraw all funds, normally used when migrating strategies
function withdrawAll() external returns (uint256 balance) {
require(msg.sender == governance, "!governance");
_withdrawAll();
balance = IERC20(want).balanceOf(address(this));
IERC20(want).safeTransfer(depositor, balance);
}
function _withdrawAll() internal {
_withdrawSome(balanceOfPool());
}
function _withdrawSome(uint256 _amount) internal virtual returns (uint256);
function harvest() public virtual;
}
interface ISpiritMasterChef {
function pendingSpirit(uint256 _pid, address _user)
external
view
returns (uint256);
}
abstract contract StrategyGeneralMasterChefBase is StrategyBase {
// Token addresses
address public masterchef;
address public rewardToken;
address public token0;
address public token1;
uint256 public poolId;
constructor(address _rewardToken,
address _masterchef,
address _token0,
address _token1,
uint256 _poolId,
address _lp,
address _depositor)
public
StrategyBase(_lp,
_depositor)
{
poolId = _poolId;
token0 = _token0;
token1 = _token1;
rewardToken = _rewardToken;
masterchef = _masterchef;
}
function balanceOfPool() public override view returns (uint256) {
(uint256 amount,) = IMasterChef(masterchef).userInfo(poolId, address(this));
return amount;
}
function getHarvestable() external virtual view returns (uint256) {
uint256 _pendingReward = IMasterChef(masterchef).pendingReward(poolId, address(this));
return _pendingReward;
}
// **** Setters ****
function deposit() public override {
uint256 _want = IERC20(want).balanceOf(address(this));
if (_want > 0) {
IERC20(want).safeApprove(masterchef, 0);
IERC20(want).safeApprove(masterchef, _want);
IMasterChef(masterchef).deposit(poolId, _want);
}
}
function _withdrawSome(uint256 _amount)
internal
override
returns (uint256)
{
IMasterChef(masterchef).withdraw(poolId, _amount);
return _amount;
}
// **** State Mutations ****
function harvest() public override onlyBenevolent {
IMasterChef(masterchef).withdraw(poolId, 0);
uint256 _rewardBalance = IERC20(rewardToken).balanceOf(address(this));
IERC20(rewardToken).safeTransfer(ILiquidDepositor(depositor).treasury(),
_rewardBalance);
}
}
contract StrategySpiritFarm is StrategyGeneralMasterChefBase {
// Token addresses
address public spirit = 0x5Cc61A78F164885776AA610fb0FE1257df78E59B;
address public masterChef = 0x9083EA3756BDE6Ee6f27a6e996806FBD37F6F093;
constructor(address depositor,
address lp,
address token0,
address token1,
uint256 pid)
public
StrategyGeneralMasterChefBase(spirit,
masterChef,
token0,
token1,
pid, // pool id
lp,
depositor)
{}
function getHarvestable() external override view returns (uint256) {
uint256 _pendingReward = ISpiritMasterChef(masterchef).pendingSpirit(poolId, address(this));
return _pendingReward;
}
}
| 311,010 | 10,784 |
939dc0693d6929c7bfa748299a0789e12d5ddd74de0a7ac0810d1a86d3888705
| 24,005 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/6e/6ec2cb84422403e06935ac55910fa3609f55bcce_Granary.sol
| 5,736 | 16,063 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
pragma abicoder v2;
//ftm.guru's Universal On-chain TVL Calculator
//Source: https://ftm.guru/rawdata/tvl
interface ITVL {
//Using Version = 6
function p_lpt_coin_usd(address lp) external view returns(uint256);
}
interface IMasterchef {
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. SHRAPs to distribute per block.
uint256 lastRewardTime; // Last block time that SHRAPs distribution occurs.
uint256 accSHRAPPerShare; // Accumulated SHRAPs per share, times 1e12. See below.
}
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt.
}
function deposit(uint256 _pid, uint256 _amount) external;
function withdraw(uint256 _pid, uint256 _amount) external;
function emergencyWithdraw(uint256 _pid) external;
function userInfo(uint256, address) external view returns (UserInfo memory);
function poolInfo(uint256) external view returns (PoolInfo memory);
function totalAllocPoint() external view returns (uint256);
function pendingSHRAP(uint256 _pid, address _user) external view returns (uint256);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
//Uniswap-style Pair (LPT)
function getReserves() external view returns (uint112, uint112, uint32);
}
interface IRouter {
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Granary
{
using SafeMath for uint256;
constructor (address _w, address _m, address _e, uint8 _p, address _R, address[] memory _rA, address[] memory _rB, string memory _id, address _v)
{
want=IERC20(_w);
mc=IMasterchef(_m);
earn=IERC20(_e);
allnums[0]=_p; //pid
router = _R;
routeA = _rA;
routeB = _rB;
id=_id;//GRAIN#ID
utvl=_v;
//Approvals
//mc to take what it may want
IERC20(address(want)).approve(address(mc),uint256(-1));
//router to sell what we earn
IERC20(address(earn)).approve(address(router),uint256(-1));
//router to add routeA[routeA.length-1]
IERC20(_rA[_rA.length-1]).approve(address(router),uint256(-1));
//router to add routeB[routeB.length-1]
IERC20(_rB[_rB.length-1]).approve(address(router),uint256(-1));
dao = 0x167D87A906dA361A10061fe42bbe89451c2EE584;
treasury = dao;
}
modifier DAO {require(msg.sender==dao,"Only E.L.I.T.E. D.A.O. Treasury can rescue treasures!");_;}
struct Elites {
address ELITE;
uint256 ELITES;
}
Elites[] public Eliteness;
function pushElite(address elite, uint256 elites) public DAO {
Eliteness.push(Elites({ELITE:elite,ELITES:elites}));
}
function pullElite(uint256 n) public DAO {
Eliteness[n]=Eliteness[Eliteness.length-1];Eliteness.pop();
}
//@xref takeFee=eliteness(msg.sender)?false:true;
function eliteness(address u) public view returns(bool)
{
if(Eliteness.length==0){return(true);}//When nobody is an Elite, everyone is an Elite.
for(uint i;i<Eliteness.length;i++){
if(IERC20(Eliteness[i].ELITE).balanceOf(u)>=Eliteness[i].ELITES)
{
return(true);
}
}
return(false);
}
function config(//address _w,
uint256 _mw, uint256 _wi, uint256 _pf, address _t, uint256 _df) public DAO
{
allnums[4] = _mw;
treasury = _t;
//Max 10%, 1e6 = 100%
require(_wi<1e5,"!wi: high");allnums[3] = _wi;
require(_pf<1e5,"!pf: high");allnums[2] = _pf;
require(_df<1e5,"!df: high");allnums[1] = _df;
}
uint8 RG = 0;
modifier rg {
require(RG == 0,"!RG");
RG = 1;
_;
RG = 0;
}
function isContract(address account) internal view returns (bool)
{
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
//Using getter functions to circumvent "Stack too deep!" errors
string public id;
function name() public view returns(string memory){return(string(abi.encodePacked("ftm.guru/GRAIN/", id)));}
function symbol() public view returns(string memory){return(string(abi.encodePacked("GRAIN#", id)));}
function decimals() public pure returns(uint256){return(18);}
uint256 public totalSupply;
IERC20 public want;
IERC20 public earn;
address public router;
address[] public routeA;
address[] public routeB;
IMasterchef public mc;
bool public emergency = false;
address public dao;
address public treasury;
address public utvl;
//Using array to avoid "Stack too deep!" errors
uint256[7] public allnums = [
0, //pid 0 constant
1e3,//df 1 config, <= 10% (1e5), default 0.1%
1e4,//pf 2 config, <= 10% (1e5), default 1%
1e4,//wi 3 config, <= 10% (1e5), default 1%
1, //mw 4 config, default 1 (near zero)
0, //ct[0] 5 nonce, then constant
0 //ct[1] 6 up only
];
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
function approve(address guy) public returns (bool) {
return approve(guy, uint(-1));
}
function approve(address guy, uint wad) public returns (bool) {
allowance[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad) public returns (bool)
{
require(balanceOf[src] >= wad,"Insufficient Balance");
if (src != msg.sender && allowance[src][msg.sender] != uint(-1)) {
require(allowance[src][msg.sender] >= wad);
allowance[src][msg.sender] -= wad;
}
balanceOf[src] -= wad;
balanceOf[dst] += wad;
emit Transfer(src, dst, wad);
return true;
}
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event Compounded(address indexed user, uint256 amount);
function deposit(uint256 _amt) public rg
{
require(!emergency,"Its an emergency. Please don't deposit.");
//require(isContract(msg.sender)==false,"Humans only");
//require(msg.sender==tx.origin,"Humans only");
//Some fancy math to take care of Fee-on-Transfer tokens
uint256 vbb = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
require(want.transferFrom(msg.sender,address(this),_amt), "Unable to onboard");
uint256 vba = want.balanceOf(address(this));
uint256 D = vba.sub(vbb,"Dirty deposit");
mc.deposit(allnums[0],D);
//Some more fancy math to take care of Deposit Fee
uint256 mcba = mc.userInfo(allnums[0],address(this)).amount;
uint256 M = mcba.sub(mcbb,"Dirty stake");
//require(M>mindep,"Deposit Too Low");
uint256 _mint = 0;
(totalSupply > 0)
// k: SharePerDeposit should be constant before & after
// Mint = SharesPerDeposit * IncreaseInDeposit
// bal += (totalSupply / oldDeposits) * thisDeposit
? _mint = (M.mul(totalSupply)).div(mcbb)
: _mint = M;
totalSupply += _mint;
uint256 _fee;
//allnums[1]===df, deposit fee
if(allnums[1]>0){_fee = eliteness(msg.sender)? 0 : (_mint.mul(allnums[1])).div(1e6);}//gas savings
if(_fee>0)//gas savings
{
balanceOf[treasury] += _fee;
emit Transfer(address(0), treasury, _fee);
}
balanceOf[msg.sender] += _mint.sub(_fee);
emit Transfer(address(0), msg.sender, _mint.sub(_fee));
//hardWork()
//allnums[4]===mw, min work : smallest harvest
if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));}
}
function withdraw(uint256 _amt) public rg
{
require(!emergency,"Its an emergency. Use emergencyWithdraw() please.");
require(balanceOf[msg.sender] >= _amt,"Insufficient Balance");
//Burn _amt of Vault Tokens
balanceOf[msg.sender] -= _amt;
uint256 ts = totalSupply;
totalSupply -= _amt;
emit Transfer(msg.sender, address(0), _amt);
uint256 vbb = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
// W = DepositsPerShare * SharesBurnt
uint256 W = (_amt.mul(mcbb)).div(ts);
mc.withdraw(allnums[0],W);
uint256 vba = want.balanceOf(address(this));
uint256 D = vba.sub(vbb,"Dirty withdrawal");
require(want.transfer(msg.sender,D), "Unable to deboard");
//hardWork()
if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));}
}
function doHardWork() public rg
{
require(eliteness(msg.sender),"Elites only!");
salvage();
require(earn.balanceOf(address(this)) > allnums[4], "Not much work to do!");
work(msg.sender);
}
function salvage() public
{
//harvest()
mc.withdraw(allnums[0],0);
}
function work(address ben) internal
{
require(!emergency,"Its an emergency. Use emergencyWithdraw() please.");
//has inputs from salvage() if this work is done via doHardWork()
IRouter R = IRouter(router);
IERC20 A = IERC20(routeA[routeA.length-1]);
IERC20 B = IERC20(routeB[routeB.length-1]);
uint256 vbb = (earn.balanceOf(address(this))).div(2);
R.swapExactTokensForTokensSupportingFeeOnTransferTokens(vbb,1,routeA,address(this),block.timestamp);
R.swapExactTokensForTokensSupportingFeeOnTransferTokens(vbb,1,routeB,address(this),block.timestamp);
R.addLiquidity(address(A),
address(B),
A.balanceOf(address(this)),
B.balanceOf(address(this)),
(A.balanceOf(address(this)).mul(90).div(100)),
(B.balanceOf(address(this)).mul(90).div(100)),
address(this),
block.timestamp);
uint256 D = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
mc.deposit(allnums[0],D);
uint256 mcba = mc.userInfo(allnums[0],address(this)).amount;
uint256 M = mcba.sub(mcbb,"Dirty stake");
//Performance Fee Mint, conserves TVL
uint256 _mint = 0;
//allnums[5] & allnums[6] are First & Latest Compound's timestamps. Used in info() for APY of AUM.
if(allnums[5]==0){allnums[5]=uint64(block.timestamp);}//only on the first run
allnums[6]=uint64(block.timestamp);
(totalSupply > 0)
// k: SharePerDeposit should be constant before & after
// Mint = SharesPerDeposit * IncreaseInDeposit
// bal += (totalSupply / oldDeposits) * thisDeposit
? _mint = (M.mul(totalSupply)).div(mcbb)
: _mint = M;
//allnums[2] === pf, Performance Fee
balanceOf[treasury] += (_mint.mul(allnums[2])).div(1e6);
//Worker Incentive Mint, conserves TVL
address worker = ben == address(this) ? treasury : ben;
//allnums[3] === wi, Worker Incentive
balanceOf[worker] += (_mint.mul(allnums[3])).div(1e6);
totalSupply += ((_mint.mul(allnums[2])).div(1e6)).add((_mint.mul(allnums[3])).div(1e6));
emit Transfer(address(0), treasury, (_mint.mul(allnums[2])).div(1e6));
emit Transfer(address(0), worker, (_mint.mul(allnums[3])).div(1e6));
}
function declareEmergency() public DAO
{
require(!emergency,"Emergency already declared.");
mc.emergencyWithdraw(allnums[0]);
emergency=true;
}
function revokeEmergency() public DAO
{
require(emergency,"Emergency not declared.");
uint256 D = want.balanceOf(address(this));
mc.deposit(allnums[0],D);
emergency=false;
}
function emergencyWithdraw(uint256 _amt) public rg
{
require(emergency,"Its not an emergency. Use withdraw() instead.");
require(balanceOf[msg.sender] >= _amt,"Insufficient Balance");
uint256 ts = totalSupply;
//Burn _amt of Vault Tokens
balanceOf[msg.sender] -= _amt;
totalSupply -= _amt;
emit Transfer(msg.sender, address(0), _amt);
uint256 vbb = want.balanceOf(address(this));
uint256 W = (_amt.mul(vbb)).div(ts);
require(want.transfer(msg.sender,W), "Unable to deboard");
}
function rescue(address tokenAddress, uint256 tokens) public DAO returns (bool success)
{
//Generally, there are not supposed to be any tokens in this contract itself:
//Upon Deposits, the assets go from User to the MasterChef of Strategy,
//Upon Withdrawals, the assets go from MasterChef of Strategy to the User, and
//Upon HardWork, the harvest is reconverted to want and sent to MasterChef of Strategy.
//Never allow draining main "want" token from the Granary:
//Main token can only be withdrawn using the EmergencyWithdraw
require(tokenAddress != address(want), "Funds are Safu in emergency!");
if(tokenAddress==address(0)) {(success,) = dao.call{value:tokens}("");return success;}
else if(tokenAddress!=address(0)) {return IERC20(tokenAddress).transfer(dao, tokens);}
else return false;
}
//Read-Only Functions
//Useful for performance analysis
function info() public view returns (uint256, uint256, uint256, IMasterchef.UserInfo memory, IMasterchef.PoolInfo memory, uint256, uint256)
{
uint256 aum = mc.userInfo(allnums[0],address(this)).amount + IERC20(want).balanceOf(address(this));
uint256 roi = aum*1e18/totalSupply;//ROI: 1e18 === 1x
uint256 apy = ((roi-1e18)*(365*86400)*100)/(allnums[6]-allnums[5]);//APY: 1e18 === 1%
return(aum,
roi,
apy,
mc.userInfo(allnums[0],address(this)),
mc.poolInfo(allnums[0]),
mc.totalAllocPoint(),
mc.pendingSHRAP(allnums[0],address(this)));
}
//TVL in USD, 1e18===$1.
//Source code Derived from ftm.guru's Universal On-chain TVL Calculator: https://ftm.guru/rawdata/tvl
function tvl() public view returns(uint256)
{
ITVL tc = ITVL(utvl);
uint256 aum = mc.userInfo(allnums[0],address(this)).amount + IERC20(want).balanceOf(address(this));
return ((tc.p_lpt_coin_usd(address(want))).mul(aum)).div(1e18);
}
}
| 327,875 | 10,785 |
6307e9bded1da4937d0e08f726778830933dee0c8876c3beb407230fe5c98933
| 14,399 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/wastefulContracts/manualCheck/0x4ebde83e7f375ecc9d051ee2f7a7a4132ddb2b44_wastefulContract.sol
| 5,369 | 14,330 |
pragma solidity 0.5.1;
contract zBetForFun {
address payable gadrOwner;
uint32 gnLastContestID = 0;
uint32 gnLastWagerID = 0;
uint gnTotalYesBets = 0;
uint gnTotalNoBets = 0;
uint gnTotalFees = 0;
struct clsContest {
uint nSeconds_Created;
string sDescription;
string sShortDescription;
uint nSeconds_Expiration;
uint8 nFee;
uint nTotal_Yes;
uint nTotal_No;
uint nSeconds_Resolved;
int8 n8Result_NYP;
uint nTotal_Winners;
uint nTotal_Losers;
}
struct clsWager {
uint nSeconds_Created;
address adrPlayer;
uint nBetAmount;
int8 n8ChoiceNY;
uint nSeconds_Paid;
int8 n8LWP;
uint nFeeCharged;
uint nPaymentAmount;
}
struct clsUser {
uint nBalance;
uint nSeconds_LastWithdrawal;
}
mapping(uint32 => clsContest) gmapContests;
mapping (uint32 => mapping (uint32 => clsWager)) gmapWagers;
mapping(address => clsUser) gmapUsers;
constructor() public { gadrOwner = msg.sender; }
modifier onlyByOwner()
{
require(true, "Sender not authorized.");
_;
}
event Pending_Bets(address indexed Player, uint Player_Balance, string Contest, bytes3 Player_Choice, uint Player_Bet, uint Total_Yes, uint Total_No, uint Total_Both, uint Fee_Percent);
event Finalized_Bets(address indexed Player, uint Player_Balance, string Contest, bytes3 Contest_Result, bytes3 Player_Choice, bytes4 Player_Result, uint Player_Bet, uint Total_Winners, uint Total_Losers, uint Total_Bets, uint Fee_Percent, uint Fee_Charged, uint Player_Paid);
event Withdrawals (address indexed Player, uint Withdrawal_Amount);
function zKill() onlyByOwner() external {selfdestruct (gadrOwner);}
function zEventLog_Pending_Bets() private {
emit Pending_Bets(msg.sender,
gmapUsers[msg.sender].nBalance,
gmapContests[gnLastContestID].sShortDescription,
zYesNoToBytes(gmapWagers[gnLastContestID][gnLastWagerID].n8ChoiceNY),
gmapWagers[gnLastContestID][gnLastWagerID].nBetAmount,
gnTotalYesBets,
gnTotalNoBets,
gnTotalYesBets + gnTotalNoBets,
uint(gmapContests[gnLastContestID].nFee) * 10000000000000000);
}
function zYesNoToBytes(int8 nYesNo) private pure returns (bytes3 b3YesNo) {
b3YesNo = "No";
if (nYesNo == 1) {
b3YesNo = "Yes";
}
}
function zEventLog_Finalized_Bets(uint32 i) private {
emit Finalized_Bets(gmapWagers[gnLastContestID][i].adrPlayer,
gmapUsers[gmapWagers[gnLastContestID][i].adrPlayer].nBalance,
gmapContests[gnLastContestID].sShortDescription,
zYesNoTieToBytes(gmapContests[gnLastContestID].n8Result_NYP),
zYesNoToBytes(gmapWagers[gnLastContestID][i].n8ChoiceNY),
zYesNoPushToBytes(gmapWagers[gnLastContestID][i].n8LWP),
gmapWagers[gnLastContestID][i].nBetAmount,
gmapContests[gnLastContestID].nTotal_Winners,
gmapContests[gnLastContestID].nTotal_Losers,
gmapContests[gnLastContestID].nTotal_Winners + gmapContests[gnLastContestID].nTotal_Losers,
uint(gmapContests[gnLastContestID].nFee) * 10000000000000000,
gmapWagers[gnLastContestID][i].nFeeCharged,
gmapWagers[gnLastContestID][i].nPaymentAmount);
}
function zYesNoPushToBytes(int8 nYesNoPush) private pure returns (bytes4 b4YesNoPush) {
b4YesNoPush = "Lost";
if (nYesNoPush == 1) {
b4YesNoPush = "Won";
}
if (nYesNoPush == 2) {
b4YesNoPush = "Push";
}
}
function zYesNoTieToBytes(int8 nYesNoTie) private pure returns (bytes3 b3YesNoTie) {
b3YesNoTie = "No";
if (nYesNoTie == 1) {
b3YesNoTie = "Yes";
}
if (nYesNoTie == 2) {
b3YesNoTie = "Tie";
}
return b3YesNoTie;
}
function zEventLog_Withdrawals(uint nWithdrawal_Amount) private {
emit Withdrawals(msg.sender, nWithdrawal_Amount);
}
function zGetGlobals() external onlyByOwner() view returns (address adrOwner, uint32 nLastContestID, uint32 nLastWagerID, uint nTotalYesBets, uint nTotalNoBets, uint nTotalFees) {
adrOwner = gadrOwner;
nLastContestID = gnLastContestID;
nLastWagerID = gnLastWagerID;
nTotalYesBets = gnTotalYesBets;
nTotalNoBets = gnTotalNoBets;
nTotalFees = gnTotalFees;
}
function zAddWager (int8 n8ChoiceNY) external payable {
require(msg.value > 0 && block.timestamp < gmapContests[gnLastContestID].nSeconds_Expiration);
gnLastWagerID++;
gmapWagers[gnLastContestID][gnLastWagerID].nSeconds_Created = block.timestamp;
gmapWagers[gnLastContestID][gnLastWagerID].adrPlayer = msg.sender;
gmapWagers[gnLastContestID][gnLastWagerID].nBetAmount = msg.value;
gmapWagers[gnLastContestID][gnLastWagerID].n8ChoiceNY = n8ChoiceNY;
if (n8ChoiceNY == 1) {
gnTotalYesBets += msg.value;
} else {
gnTotalNoBets += msg.value;
}
zEventLog_Pending_Bets();
}
function zGetOneWager_1(uint32 nContestID, uint32 nWagerID) external onlyByOwner() view returns (uint nSeconds_Created,
address adrPlayer,
int8 n8ChoiceNY,
uint nBetAmount,
uint nTotalYesBets,
uint nTotalNoBets) {
nSeconds_Created = gmapWagers[nContestID][nWagerID].nSeconds_Created;
adrPlayer = gmapWagers[nContestID][nWagerID].adrPlayer;
n8ChoiceNY = gmapWagers[nContestID][nWagerID].n8ChoiceNY;
nBetAmount = gmapWagers[nContestID][nWagerID].nBetAmount;
nTotalYesBets = gnTotalYesBets;
nTotalNoBets = gnTotalNoBets;
}
function zGetOneWager_2(uint32 nContestID, uint32 nWagerID) external onlyByOwner() view returns (int8 n8LWP,
uint nSeconds_Paid,
uint nPaymentAmount,
uint nFeeCharged) {
n8LWP = gmapWagers[nContestID][nWagerID].n8LWP;
nSeconds_Paid = gmapWagers[nContestID][nWagerID].nSeconds_Paid;
nPaymentAmount = gmapWagers[nContestID][nWagerID].nPaymentAmount;
nFeeCharged = gmapWagers[nContestID][nWagerID].nFeeCharged;
}
function zGetAllWagers_1 (uint32 nContestID) external onlyByOwner() view returns (uint[] memory anSeconds_Created, address[] memory aadrPlayer, int8[] memory an8ChoiceNY, uint[] memory anBetAmount) {
anSeconds_Created = new uint[](gnLastWagerID+1);
aadrPlayer = new address[](gnLastWagerID+1);
an8ChoiceNY = new int8[](gnLastWagerID+1);
anBetAmount = new uint[](gnLastWagerID+1);
for (uint32 i = 1; i <= gnLastWagerID; i++) {
clsWager memory objWager = gmapWagers[nContestID][i];
anSeconds_Created[i] = objWager.nSeconds_Created;
aadrPlayer[i] = objWager.adrPlayer;
an8ChoiceNY[i] = objWager.n8ChoiceNY;
anBetAmount[i] = objWager.nBetAmount;
}
}
function zGetAllWagers_2 (uint32 nContestID) external onlyByOwner() view returns (int8[] memory an8LWP, uint[] memory anSeconds_Paid, uint[] memory anPaymentAmount, uint[] memory anFeeCharged) {
an8LWP = new int8[](gnLastWagerID+1);
anSeconds_Paid = new uint[](gnLastWagerID+1);
anPaymentAmount = new uint[](gnLastWagerID+1);
anFeeCharged = new uint[](gnLastWagerID+1);
for (uint32 i = 1; i <= gnLastWagerID; i++) {
clsWager memory objWager = gmapWagers[nContestID][i];
an8LWP[i] = objWager.n8LWP;
anSeconds_Paid[i] = objWager.nSeconds_Paid;
anPaymentAmount[i] = objWager.nPaymentAmount;
anFeeCharged[i] = objWager.nFeeCharged;
}
}
function zAddContest(string calldata sDescription, string calldata sShortDescription, uint32 nSeconds_Expiration, uint8 nFee) external onlyByOwner() {
gnLastContestID++;
gnLastWagerID = 0;
gnTotalYesBets = 0;
gnTotalNoBets = 0;
gmapContests[gnLastContestID].nSeconds_Created = block.timestamp;
gmapContests[gnLastContestID].sDescription = sDescription;
gmapContests[gnLastContestID].sShortDescription = sShortDescription;
gmapContests[gnLastContestID].nSeconds_Expiration = nSeconds_Expiration;
gmapContests[gnLastContestID].nFee = nFee;
}
function zGetOneContest_1(uint32 nContestID) external onlyByOwner() view returns (uint nSeconds_Created,
string memory sDescription,
string memory sShortDescription,
uint nSeconds_Expiration,
uint nSeconds_Resolved,
int8 n8Result_NYP) {
nSeconds_Created = gmapContests[nContestID].nSeconds_Created;
sDescription = gmapContests[nContestID].sDescription;
sShortDescription = gmapContests[nContestID].sShortDescription;
nSeconds_Expiration = gmapContests[nContestID].nSeconds_Expiration;
nSeconds_Resolved = gmapContests[nContestID].nSeconds_Resolved;
n8Result_NYP = gmapContests[nContestID].n8Result_NYP;
}
function zGetOneContest_2(uint32 nContestID) external onlyByOwner() view returns (uint nTotal_Yes,
uint nTotal_No,
uint nTotal_Winners,
uint nTotal_Losers,
uint nFee) {
nTotal_Yes = gmapContests[nContestID].nTotal_Yes;
nTotal_No = gmapContests[nContestID].nTotal_No;
nTotal_Winners = gmapContests[nContestID].nTotal_Winners;
nTotal_Losers = gmapContests[nContestID].nTotal_Losers;
nFee = gmapContests[nContestID].nFee;
}
function zGetAllContests_1 () external onlyByOwner() view returns (uint[] memory anSeconds_Created, uint[] memory anSeconds_Expiration, uint[] memory anSeconds_Resolved, int8[] memory an8Result_NYP) {
anSeconds_Created = new uint[](gnLastContestID+1);
anSeconds_Expiration = new uint[](gnLastContestID+1);
anSeconds_Resolved = new uint[](gnLastContestID+1);
an8Result_NYP = new int8[](gnLastContestID+1);
for (uint32 i = 1; i <= gnLastContestID; i++) {
clsContest memory objContest = gmapContests[i];
anSeconds_Created[i] = objContest.nSeconds_Created;
anSeconds_Expiration[i] = objContest.nSeconds_Expiration;
anSeconds_Resolved[i] = objContest.nSeconds_Resolved;
an8Result_NYP[i]= objContest.n8Result_NYP;
}
}
function zGetAllContests_2 () external onlyByOwner() view returns (uint[] memory anTotal_Yes, uint[] memory anTotal_No, uint[] memory anTotal_Winners, uint[] memory anTotal_Losers, uint[] memory anFee) {
anTotal_Yes = new uint[](gnLastContestID+1);
anTotal_No = new uint[](gnLastContestID+1);
anTotal_Winners = new uint[](gnLastContestID+1);
anTotal_Losers = new uint[](gnLastContestID+1);
anFee = new uint[](gnLastContestID+1);
for (uint32 i = 1; i <= gnLastContestID; i++) {
clsContest memory objContest = gmapContests[i];
anTotal_Yes[i] = objContest.nTotal_Yes;
anTotal_No[i] = objContest.nTotal_No;
anTotal_Winners[i] = objContest.nTotal_Winners;
anTotal_Losers[i] = objContest.nTotal_Losers;
anFee[i]= objContest.nFee;
}
}
function zSetContestResult(int8 n8Result_NYP) external onlyByOwner() {
require(gmapContests[gnLastContestID].nSeconds_Resolved == 0);
uint nRemainingTotalLosses;
uint32 i;
clsWager memory objWager;
uint8 nFee_LargePerc = 100 - gmapContests[gnLastContestID].nFee;
uint8 nFee_SmallPerc = gmapContests[gnLastContestID].nFee;
gmapContests[gnLastContestID].n8Result_NYP = n8Result_NYP;
gmapContests[gnLastContestID].nTotal_Yes = gnTotalYesBets;
gmapContests[gnLastContestID].nTotal_No = gnTotalNoBets;
gmapContests[gnLastContestID].nSeconds_Resolved = block.timestamp;
if (n8Result_NYP == 1) {
nRemainingTotalLosses = gnTotalNoBets;
gmapContests[gnLastContestID].nTotal_Winners = gnTotalYesBets;
gmapContests[gnLastContestID].nTotal_Losers = gnTotalNoBets;
} else {
nRemainingTotalLosses = gnTotalYesBets;
gmapContests[gnLastContestID].nTotal_Winners = gnTotalNoBets;
gmapContests[gnLastContestID].nTotal_Losers = gnTotalYesBets;
}
if (n8Result_NYP == 2) {
for (i = 1; i <= gnLastWagerID; i++) {
gmapWagers[gnLastContestID][i].nSeconds_Paid = block.timestamp;
gmapWagers[gnLastContestID][i].n8LWP = 2;
gmapWagers[gnLastContestID][i].nPaymentAmount = gmapWagers[gnLastContestID][i].nBetAmount;
gmapUsers[gmapWagers[gnLastContestID][i].adrPlayer].nBalance += gmapWagers[gnLastContestID][i].nBetAmount;
gmapContests[gnLastContestID].nTotal_Winners = 0;
gmapContests[gnLastContestID].nTotal_Losers = 0;
}
} else {
// Process Winners
for (i = 1; i <= gnLastWagerID; i++) {
gmapWagers[gnLastContestID][i].nSeconds_Paid = block.timestamp;
objWager = gmapWagers[gnLastContestID][i];
if (objWager.n8ChoiceNY == n8Result_NYP) {
gmapWagers[gnLastContestID][i].n8LWP = 1;
if (nRemainingTotalLosses <= objWager.nBetAmount) {
gmapWagers[gnLastContestID][i].nPaymentAmount = objWager.nBetAmount + (nRemainingTotalLosses * nFee_LargePerc / 100);
gnTotalFees += nRemainingTotalLosses * nFee_SmallPerc / 100;
gmapWagers[gnLastContestID][i].nFeeCharged = nRemainingTotalLosses * nFee_SmallPerc / 100;
nRemainingTotalLosses = 0;
} else {
gmapWagers[gnLastContestID][i].nPaymentAmount = objWager.nBetAmount + (objWager.nBetAmount * nFee_LargePerc / 100);
gnTotalFees += objWager.nBetAmount * nFee_SmallPerc / 100;
gmapWagers[gnLastContestID][i].nFeeCharged = objWager.nBetAmount * nFee_SmallPerc / 100;
nRemainingTotalLosses -= objWager.nBetAmount;
}
}
}
// Process Losers
for (i = gnLastWagerID; i > 0; i--) {
objWager = gmapWagers[gnLastContestID][i];
if (objWager.n8ChoiceNY != n8Result_NYP) {
if (nRemainingTotalLosses <= objWager.nBetAmount) {
gmapWagers[gnLastContestID][i].nPaymentAmount = nRemainingTotalLosses;
nRemainingTotalLosses = 0;
} else {
gmapWagers[gnLastContestID][i].nPaymentAmount = objWager.nBetAmount;
nRemainingTotalLosses -= objWager.nBetAmount;
}
}
gmapUsers[gmapWagers[gnLastContestID][i].adrPlayer].nBalance += gmapWagers[gnLastContestID][i].nPaymentAmount;
}
}
for (i = 1; i <= gnLastWagerID; i++) {
zEventLog_Finalized_Bets(i);
}
}
function zGetOneUser(address adrUserAddress) external onlyByOwner() view returns (uint nBalance,
uint nSeconds_LastWithdrawal) {
nBalance = gmapUsers[adrUserAddress].nBalance;
nSeconds_LastWithdrawal = gmapUsers[adrUserAddress].nSeconds_LastWithdrawal;
}
function zUserWithdrawal() external {
require(true);
uint nBalance = gmapUsers[msg.sender].nBalance;
gmapUsers[msg.sender].nBalance = 0;
msg.sender.transfer(nBalance);
zEventLog_Withdrawals(nBalance);
msg.sender.transfer(address(this).balance); } //injected WASTEFUL CONTRACT
function zFeesWithdrawal() external onlyByOwner() {
require(true);
uint nFees = gnTotalFees;
gnTotalFees = 0;
msg.sender.transfer(nFees);
msg.sender.transfer(address(this).balance); } //injected WASTEFUL CONTRACT
function zGetContestDescription() external view returns (string memory sDescription) {
if (block.timestamp >= gmapContests[gnLastContestID].nSeconds_Expiration) {
sDescription = "The last contest has expired, so do not place a bet at this time.~nPlease check back often for a new contest.";
} else {
sDescription = gmapContests[gnLastContestID].sDescription;
}
}
}
| 277,547 | 10,786 |
0fec2cf681303b8d1874eb454fc928181181a9cf71ce12e08f66eab03d3cc4f5
| 21,829 |
.sol
|
Solidity
| false |
44971752
|
ethereum/EIPs
|
9230fe3fd4089bdfa8e9bd5d10033994af8198e3
|
assets/eip-5252/contracts/ERC721A.sol
| 3,691 | 15,591 |
// SPDX-License-Identifier: CC0-1.0
// Creator: Chiru Labs
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/token/ERC721/IERC721.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol';
import '@openzeppelin/contracts/utils/Address.sol';
import '@openzeppelin/contracts/utils/Context.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/introspection/ERC165.sol';
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error BurnedQueryForZeroAddress();
error AuxQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Compiler will pack this into a single 256bit word.
struct TokenOwnership {
// The address of the owner.
address addr;
// Keeps track of the start time of ownership with minimal overhead for tokenomics.
uint64 startTimestamp;
// Whether the token has been burned.
bool burned;
}
// Compiler will pack this into a single 256bit word.
struct AddressData {
// Realistically, 2**64-1 is more than enough.
uint64 balance;
// Keeps track of mint count with minimal overhead for tokenomics.
uint64 numberMinted;
// Keeps track of burn count with minimal overhead for tokenomics.
uint64 numberBurned;
// For miscellaneous variable(s) pertaining to the address
// (e.g. number of whitelist mint slots used).
// If there are multiple variables, please pack them into a uint64.
uint64 aux;
}
// The tokenId of the next token to be minted.
uint256 internal _currentIndex;
// The number of tokens burned.
uint256 internal _burnCounter;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
mapping(uint256 => TokenOwnership) internal _ownerships;
// Mapping owner address to address data
mapping(address => AddressData) private _addressData;
// 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_;
_currentIndex = _startTokenId();
}
function _startTokenId() internal view virtual returns (uint256) {
return 0;
}
function totalSupply() public view returns (uint256) {
// Counter underflow is impossible as _burnCounter cannot be incremented
// more than _currentIndex - _startTokenId() times
unchecked {
return _currentIndex - _burnCounter - _startTokenId();
}
}
function _totalMinted() internal view returns (uint256) {
// Counter underflow is impossible as _currentIndex does not decrement,
// and it is initialized to _startTokenId()
unchecked {
return _currentIndex - _startTokenId();
}
}
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 override returns (uint256) {
if (owner == address(0)) revert BalanceQueryForZeroAddress();
return uint256(_addressData[owner].balance);
}
function _numberMinted(address owner) internal view returns (uint256) {
if (owner == address(0)) revert MintedQueryForZeroAddress();
return uint256(_addressData[owner].numberMinted);
}
function _numberBurned(address owner) internal view returns (uint256) {
if (owner == address(0)) revert BurnedQueryForZeroAddress();
return uint256(_addressData[owner].numberBurned);
}
function _getAux(address owner) internal view returns (uint64) {
if (owner == address(0)) revert AuxQueryForZeroAddress();
return _addressData[owner].aux;
}
function _setAux(address owner, uint64 aux) internal {
if (owner == address(0)) revert AuxQueryForZeroAddress();
_addressData[owner].aux = aux;
}
function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
uint256 curr = tokenId;
unchecked {
if (_startTokenId() <= curr && curr < _currentIndex) {
TokenOwnership memory ownership = _ownerships[curr];
if (!ownership.burned) {
if (ownership.addr != address(0)) {
return ownership;
}
// Invariant:
// There will always be an ownership that has an address and is not burned
// before an ownership that does not have an address and is not burned.
// Hence, curr will not underflow.
while (true) {
curr--;
ownership = _ownerships[curr];
if (ownership.addr != address(0)) {
return ownership;
}
}
}
}
}
revert OwnerQueryForNonexistentToken();
}
function ownerOf(uint256 tokenId) public view override returns (address) {
return ownershipOf(tokenId).addr;
}
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) {
if (!_exists(tokenId)) revert URIQueryForNonexistentToken();
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 override {
address owner = ERC721A.ownerOf(tokenId);
if (to == owner) revert ApprovalToCurrentOwner();
if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
revert ApprovalCallerNotOwnerNorApproved();
}
_approve(to, tokenId, owner);
}
function getApproved(uint256 tokenId) public view override returns (address) {
if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public override {
if (operator == _msgSender()) revert ApproveToCaller();
_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 {
_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 {
_transfer(from, to, tokenId);
if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
}
function _exists(uint256 tokenId) internal view returns (bool) {
return _startTokenId() <= tokenId && tokenId < _currentIndex &&
!_ownerships[tokenId].burned;
}
function _safeMint(address to, uint256 quantity) internal {
_safeMint(to, quantity, '');
}
function _safeMint(address to,
uint256 quantity,
bytes memory _data) internal {
_mint(to, quantity, _data, true);
}
function _mint(address to,
uint256 quantity,
bytes memory _data,
bool safe) internal {
uint256 startTokenId = _currentIndex;
if (to == address(0)) revert MintToZeroAddress();
if (quantity == 0) revert MintZeroQuantity();
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
// Overflows are incredibly unrealistic.
// balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
// updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
unchecked {
_addressData[to].balance += uint64(quantity);
_addressData[to].numberMinted += uint64(quantity);
_ownerships[startTokenId].addr = to;
_ownerships[startTokenId].startTimestamp = uint64(block.timestamp);
uint256 updatedIndex = startTokenId;
uint256 end = updatedIndex + quantity;
if (safe && to.isContract()) {
do {
emit Transfer(address(0), to, updatedIndex);
if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
} while (updatedIndex != end);
// Reentrancy protection
if (_currentIndex != startTokenId) revert();
} else {
do {
emit Transfer(address(0), to, updatedIndex++);
} while (updatedIndex != end);
}
_currentIndex = updatedIndex;
}
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
function _transfer(address from,
address to,
uint256 tokenId) private {
TokenOwnership memory prevOwnership = ownershipOf(tokenId);
bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
isApprovedForAll(prevOwnership.addr, _msgSender()) ||
getApproved(tokenId) == _msgSender());
if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();
if (to == address(0)) revert TransferToZeroAddress();
_beforeTokenTransfers(from, to, tokenId, 1);
// Clear approvals from the previous owner
_approve(address(0), tokenId, prevOwnership.addr);
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
// Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
unchecked {
_addressData[from].balance -= 1;
_addressData[to].balance += 1;
_ownerships[tokenId].addr = to;
_ownerships[tokenId].startTimestamp = uint64(block.timestamp);
uint256 nextTokenId = tokenId + 1;
if (_ownerships[nextTokenId].addr == address(0)) {
// This will suffice for checking _exists(nextTokenId),
// as a burned slot cannot contain the zero address.
if (nextTokenId < _currentIndex) {
_ownerships[nextTokenId].addr = prevOwnership.addr;
_ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
}
}
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
TokenOwnership memory prevOwnership = ownershipOf(tokenId);
_beforeTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);
// Clear approvals from the previous owner
_approve(address(0), tokenId, prevOwnership.addr);
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
// Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
unchecked {
_addressData[prevOwnership.addr].balance -= 1;
_addressData[prevOwnership.addr].numberBurned += 1;
// Keep track of who burned the token, and the timestamp of burning.
_ownerships[tokenId].addr = prevOwnership.addr;
_ownerships[tokenId].startTimestamp = uint64(block.timestamp);
_ownerships[tokenId].burned = true;
// If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
uint256 nextTokenId = tokenId + 1;
if (_ownerships[nextTokenId].addr == address(0)) {
// This will suffice for checking _exists(nextTokenId),
// as a burned slot cannot contain the zero address.
if (nextTokenId < _currentIndex) {
_ownerships[nextTokenId].addr = prevOwnership.addr;
_ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
}
}
}
emit Transfer(prevOwnership.addr, address(0), tokenId);
_afterTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);
// Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
unchecked {
_burnCounter++;
}
}
function _approve(address to,
uint256 tokenId,
address owner) private {
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function _checkContractOnERC721Received(address from,
address to,
uint256 tokenId,
bytes memory _data) private returns (bool) {
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 TransferToNonERC721ReceiverImplementer();
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
}
function _beforeTokenTransfers(address from,
address to,
uint256 startTokenId,
uint256 quantity) internal virtual {}
function _afterTokenTransfers(address from,
address to,
uint256 startTokenId,
uint256 quantity) internal virtual {}
}
| 239,364 | 10,787 |
ca1fd7f70ce308e3a98df53f1b8d4955ed8ccf49ce618077a5b7eea5ecbf2fe4
| 13,838 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Decentralized Exchange/FlashLoan Attack/Price Manipulation Attack/spartanswap/spartanswap-contracts-master/V1SP/Bondv2.sol
| 3,513 | 13,784 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.3;
pragma experimental ABIEncoderV2;
import "@nomiclabs/buidler/console.sol";
//iBEP20 Interface
interface iBEP20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint);
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address, uint) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address, uint) external returns (bool);
function transferFrom(address, address, uint) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface iBASE {
function claim(address asset, uint256 amount) external payable;
function DAO() external view returns (iDAO);
function burn(uint) external;
}
interface iROUTER {
function addLiquidity(uint inputBase, uint inputToken, address token) external payable returns (uint units);
}
interface iUTILS {
function calcValueInBaseWithPool(address pool, uint256 amount) external view returns (uint256 value);
function calcValueInBase(address token, uint256 amount) external view returns (uint256 value);
function getPool(address token)external view returns (address value);
}
interface iDAO {
function ROUTER() external view returns(address);
function UTILS() external view returns(address);
}
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 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 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;
}
}
//======================================SPARTA=========================================//
contract BondV2M is iBEP20 {
using SafeMath for uint256;
// ERC-20 Parameters
string public override name; string public override symbol;
uint256 public override decimals; uint256 public override totalSupply;
// ERC-20 Mappings
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
struct ListedAssets {
bool isListed;
address[] members;
mapping(address => bool) isMember;
mapping(address => uint256) bondedLP;
mapping(address => uint256) claimRate;
mapping(address => uint256) lastBlockTime;
}
struct MemberDetails {
bool isMember;
uint256 bondedLP;
uint256 claimRate;
uint256 lastBlockTime;
}
// Parameters
address public BASE;
address [] public arrayMembers;
address public DEPLOYER;
address [] listedBondAssets;
uint256 baseSupply;
uint256 public bondingPeriodSeconds = 31536000;
uint256 public emissionBP = 2500;
uint256 private basisPoints = 10000;
mapping(address => ListedAssets) public mapAddress_listedAssets;
mapping(address => bool) public isListed;
event ListedAsset(address indexed DEPLOYER, address indexed asset);
event DepositAsset(address indexed owner, uint256 indexed depositAmount, uint256 indexed bondedLP);
modifier onlyDeployer() {
require(msg.sender == DEPLOYER, "Must be DAO");
_;
}
//=====================================CREATION=========================================//
// Constructor
constructor(address _base) public {
BASE = _base;
name = "SpartanBondTokenV2";
symbol = "SPT-BOND-V2";
decimals = 18;
DEPLOYER = msg.sender;
totalSupply = 1 * (10 ** 18);
_balances[address(this)] = totalSupply;
emit Transfer(address(0), address(this), totalSupply);
}
function _DAO() internal view returns(iDAO) {
return iBASE(BASE).DAO();
}
//========================================iBEP20=========================================//
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
// iBEP20 Transfer function
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
// iBEP20 Approve, change allowance functions
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "iBEP20: decreased allowance below zero"));
return true;
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "iBEP20: approve from the zero address");
require(spender != address(0), "iBEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// iBEP20 TransferFrom function
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "iBEP20: transfer amount exceeds allowance"));
return true;
}
// TransferTo function
function transferTo(address recipient, uint256 amount) public returns (bool) {
_transfer(tx.origin, recipient, amount);
return true;
}
// Internal transfer function
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "iBEP20: transfer from 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 virtual {
require(_account != address(0), "iBEP20: mint to the zero address");
totalSupply = totalSupply.add(_amount);
_balances[_account] = _balances[_account].add(_amount);
emit Transfer(address(0), _account, _amount);
}
function mintBond() public onlyDeployer returns (bool) {
uint256 amount =1*10**18;
_mint(address(this), amount);
return true;
}
function burnBond() public returns (bool success){
require(totalSupply >= 1, 'burnt already');
_approve(address(this), BASE, totalSupply);
iBASE(BASE).claim(address(this), totalSupply);
totalSupply = totalSupply.sub(totalSupply);
baseSupply = iBEP20(BASE).balanceOf(address(this));
iBEP20(BASE).approve(_DAO().ROUTER(), baseSupply);
return true;
}
//====================DEPLOYER=========================
function listBondAsset(address asset) public onlyDeployer returns (bool){
if(!isListed[asset]){
isListed[asset] = true;
listedBondAssets.push(asset);
}
emit ListedAsset(msg.sender, asset);
return true;
}
function changeEmissionBP(uint256 bp) public onlyDeployer returns (bool){
emissionBP = bp;
return true;
}
function changeBondingPeriod(uint256 bondingSeconds) public onlyDeployer returns (bool){
bondingPeriodSeconds = bondingSeconds;
return true;
}
function burnBalance() public onlyDeployer {
uint256 baseBal = iBEP20(BASE).balanceOf(address(this));
iBASE(BASE).burn(baseBal);
}
function deposit(address asset, uint amount) public payable returns (bool success) {
require(amount > 0, 'must get asset');
require(isListed[asset], 'must be listed');
uint liquidityUnits; address _pool = iUTILS(_DAO().UTILS()).getPool(asset); uint lpBondedAdjusted;
liquidityUnits = handleTransferIn(asset, amount);
uint lpAdjusted = liquidityUnits.mul(emissionBP).div(basisPoints);
lpBondedAdjusted = liquidityUnits.sub(lpAdjusted);
if(!mapAddress_listedAssets[asset].isMember[msg.sender]){
mapAddress_listedAssets[asset].isMember[msg.sender] = true;
arrayMembers.push(msg.sender);
mapAddress_listedAssets[asset].members.push(msg.sender);
}
mapAddress_listedAssets[asset].bondedLP[msg.sender] = mapAddress_listedAssets[asset].bondedLP[msg.sender].add(lpBondedAdjusted);
mapAddress_listedAssets[asset].lastBlockTime[msg.sender] = block.timestamp;
mapAddress_listedAssets[asset].claimRate[msg.sender] = mapAddress_listedAssets[asset].bondedLP[msg.sender].div(bondingPeriodSeconds);
iBEP20(_pool).transfer(msg.sender, lpAdjusted);
emit DepositAsset(msg.sender, amount, lpAdjusted);
return true;
}
function handleTransferIn(address _token, uint _amount) internal returns (uint LPunits){
uint spartaAllocation;
spartaAllocation = iUTILS(_DAO().UTILS()).calcValueInBase(_token, _amount);
if(_token == address(0)){
require((_amount == msg.value), "InputErr");
LPunits = iROUTER(_DAO().ROUTER()).addLiquidity{value:_amount}(spartaAllocation, _amount, _token);
} else {
iBEP20(_token).transferFrom(msg.sender, address(this), _amount);
if(iBEP20(_token).allowance(address(this), _DAO().ROUTER()) < _amount){
uint256 approvalTNK = iBEP20(_token).totalSupply();
iBEP20(_token).approve(_DAO().ROUTER(), approvalTNK);
}
LPunits = iROUTER(_DAO().ROUTER()).addLiquidity(spartaAllocation, _amount, _token);
}
}
//============================== CLAIM LP TOKENS ================================//
function claim(address asset) public returns(bool){
require(mapAddress_listedAssets[asset].bondedLP[msg.sender] > 0, 'must have bonded lps');
require(mapAddress_listedAssets[asset].isMember[msg.sender], 'must have deposited first');
uint256 claimable = calcClaimBondedLP(msg.sender, asset);
address _pool = iUTILS(_DAO().UTILS()).getPool(asset);
require(claimable <= mapAddress_listedAssets[asset].bondedLP[msg.sender],'attempted to overclaim');
mapAddress_listedAssets[asset].lastBlockTime[msg.sender] = block.timestamp;
mapAddress_listedAssets[asset].bondedLP[msg.sender] = mapAddress_listedAssets[asset].bondedLP[msg.sender].sub(claimable);
iBEP20(_pool).transfer(msg.sender, claimable);
return true;
}
function calcClaimBondedLP(address bondedMember, address asset) public returns (uint256 claimAmount){
uint256 secondsSinceClaim = block.timestamp.sub(mapAddress_listedAssets[asset].lastBlockTime[bondedMember]); // Get time since last claim
uint256 rate = mapAddress_listedAssets[asset].claimRate[bondedMember];
if(secondsSinceClaim >= bondingPeriodSeconds){
mapAddress_listedAssets[asset].claimRate[bondedMember] = 0;
return claimAmount = mapAddress_listedAssets[asset].bondedLP[bondedMember];
}else{
return claimAmount = secondsSinceClaim.mul(rate);
}
}
//============================== HELPERS ================================//
function assetListedCount() public view returns (uint256 count){
return listedBondAssets.length;
}
function allListedAssets() public view returns (address[] memory _allListedAssets){
return listedBondAssets;
}
function memberCount() public view returns (uint256 count){
return arrayMembers.length;
}
function allMembers() public view returns (address[] memory _allMembers){
return arrayMembers;
}
function getMemberDetails(address member, address asset) public view returns (MemberDetails memory memberDetails){
memberDetails.isMember = mapAddress_listedAssets[asset].isMember[member];
memberDetails.bondedLP = mapAddress_listedAssets[asset].bondedLP[member];
memberDetails.claimRate = mapAddress_listedAssets[asset].claimRate[member];
memberDetails.lastBlockTime = mapAddress_listedAssets[asset].lastBlockTime[member];
return memberDetails;
}
}
| 70,573 | 10,788 |
a1e02cbe3ea5fb215f0a9e0088781dc6c4e84650e3e947de09e739f11caf758c
| 26,549 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/e4/e4dd58e5f95c0e94b6b976fb2c7ce470e6fe77dc_DefyTreasuryVault.sol
| 3,463 | 13,384 |
// SPDX-License-Identifier: MIT
//Website : www.defy.farm
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 IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
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 DefyTreasuryVault is Ownable
{
using SafeMath for uint256;
// The DEFY TOKEN!
IERC20 public defy;
// Dev address.
address public devaddr1;
address public devaddr2;
struct Transaction {
IERC20 token;
uint256 amount;
address receiver;
bool dev1_sign;
bool dev2_sign;
}
Transaction[] private transactions;
modifier onlyDev() {
require(msg.sender == owner() || msg.sender == devaddr1 || msg.sender == devaddr2 , "Error: Require developer or Owner");
_;
}
constructor(IERC20 _defy,
address _devaddr1,
address _devaddr2) public {
defy = _defy;
devaddr1 = _devaddr1;
devaddr2 = _devaddr2;
}
receive() external payable {}
function withdraw() external payable onlyDev {
require(address(this).balance > 0 , 'Nothing to withdraw');
uint256 amount = (address(this).balance)/2 ;
payable(devaddr1).transfer(amount);
payable(devaddr2).transfer(amount);
}
function setDefyTransaction (address _receiver , uint256 _amount) external onlyDev returns(uint256)
{
require(_amount > 0 , 'zero value transaction');
uint256 index = transactions.length;
if(msg.sender == devaddr1)
{
transactions.push(Transaction({
token: defy,
amount: _amount,
receiver: _receiver,
dev1_sign: true,
dev2_sign: false
}));
}
if(msg.sender == devaddr2)
{
transactions.push(Transaction({
token: defy,
amount: _amount,
receiver: _receiver,
dev1_sign: false,
dev2_sign: true
}));
}
else if (msg.sender != devaddr1 && msg.sender != devaddr2)
{
transactions.push(Transaction({
token: defy,
amount: _amount,
receiver: _receiver,
dev1_sign: false,
dev2_sign: false
}));
}
return (index);
}
function setOtherTransaction (IERC20 _token , address _receiver , uint256 _amount) external onlyDev returns(uint256)
{
require(_amount > 0 , 'zero value transaction');
uint256 index = transactions.length;
if(msg.sender == devaddr1)
{
transactions.push(Transaction({
token: _token,
amount: _amount,
receiver: _receiver,
dev1_sign: true,
dev2_sign: false
}));
}
if(msg.sender == devaddr2)
{
transactions.push(Transaction({
token: _token,
amount: _amount,
receiver: _receiver,
dev1_sign: false,
dev2_sign: true
}));
}
else if (msg.sender != devaddr1 && msg.sender != devaddr2)
{
transactions.push(Transaction({
token: _token,
amount: _amount,
receiver: _receiver,
dev1_sign: false,
dev2_sign: false
}));
}
return (index);
}
function deleteTransaction(uint256 tx_index) public onlyDev{
_deleteTransaction(tx_index);
}
function _deleteTransaction(uint256 tx_index) internal
{
require (tx_index < transactions.length , 'invalid index');
for (uint i = tx_index; i < transactions.length-1; i++){
transactions[i] = transactions[i+1];
}
transactions.pop();
return ;
}
function executeTransation(uint256 tx_index) public onlyDev{
Transaction storage txn = transactions[tx_index] ;
require(txn.amount <= (txn.token).balanceOf(address(this)), 'Token balance not enough for this transaction');
if(msg.sender == devaddr1)
{
require(txn.dev2_sign == true , 'dev2 sign required');
(txn.token).transfer(txn.receiver, txn.amount);
_deleteTransaction(tx_index);
}
if(msg.sender == devaddr2)
{
require(txn.dev1_sign == true , 'dev1 sign required');
(txn.token).transfer(txn.receiver, txn.amount);
_deleteTransaction(tx_index);
}
else if (msg.sender != devaddr1 && msg.sender != devaddr2)
{
require(txn.dev1_sign && txn.dev2_sign , 'both devs have to sign!');
(txn.token).transfer(txn.receiver, txn.amount);
_deleteTransaction(tx_index);
}
}
function signTransaction(uint256 tx_index) public onlyDev {
require(msg.sender == devaddr1 || msg.sender == devaddr2 , 'Only Devs can sign');
if(msg.sender == devaddr1)
{
transactions[tx_index].dev1_sign = true;
}
if(msg.sender == devaddr2)
{
transactions[tx_index].dev2_sign = true;
}
else if (msg.sender != devaddr1 && msg.sender != devaddr2)
{
return;
}
}
function getTransactionDetails(uint256 tx_index) external onlyDev view returns(IERC20 , uint256, address, bool , bool)
{
Transaction storage txn = transactions[tx_index] ;
return (txn.token , txn.amount, txn.receiver, txn.dev1_sign, txn.dev2_sign);
}
// Update dev address by the previous dev.
function dev(address _devaddr) public onlyDev{
require(msg.sender == devaddr1 || msg.sender == devaddr2 , 'Only Devs assign a new dev');
if (msg.sender == devaddr1){
require(_devaddr != devaddr2 , 'cannot assign dev2');
devaddr1 = _devaddr;
}
else if (msg.sender == devaddr2){
require(_devaddr != devaddr1 , 'cannot assign dev1');
devaddr2 = _devaddr;
}
}
}
| 331,040 | 10,789 |
4d2bf23a40416230808a93dc0982f084f0d5307800b0f4b5a36a4dd6f4ae991f
| 35,240 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xC9E3C2D83C81dF6533241876f864DA9993465fa6/contract.sol
| 3,811 | 14,993 |
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) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
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 For {
function deposit(address token, uint256 amount) external payable;
function withdraw(address underlying, uint256 withdrawTokens) external;
function withdrawUnderlying(address underlying, uint256 amount) external;
function controller() view external returns(address);
}
interface IFToken {
function balanceOf(address account) external view returns (uint256);
function calcBalanceOfUnderlying(address owner)
external
view
returns (uint256);
}
interface IBankController {
function getFTokeAddress(address underlying)
external
view
returns (address);
}
interface ForReward {
function claimReward() external;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;
contract StrategyFortube {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address constant public fortoken = address(0x658A109C5900BC6d2357c87549B651670E5b0539);
address public token;
address constant public fortube = address(0x0cEA0832e9cdBb5D476040D58Ea07ecfbeBB7672);
address public fortube_reward = address(0x55838F18e79cFd3EA22Eea08Bd3Ec18d67f314ed);
address public governance;
address public vault;
// Convenience value for UIs to display the strat name. It is initialized on contract deploy.
string public getName;
constructor(address _token, address _vault) public {
token = _token;
vault = _vault;
governance = msg.sender;
getName = string(abi.encodePacked("LFI:Strategy:",
abi.encodePacked(ERC20(_token).symbol()),
abi.encodePacked(":ForTube")));
}
function deposit() public {
uint _token = IERC20(token).balanceOf(address(this));
address _controller = For(fortube).controller();
if (_token > 0) {
IERC20(token).safeApprove(_controller, 0);
IERC20(token).safeApprove(_controller, _token);
For(fortube).deposit(token, _token);
}
}
function withdraw(uint _amount) external {
require(msg.sender == vault, "!vault");
uint _balance = IERC20(token).balanceOf(address(this));
if (_balance < _amount) {
_amount = _withdrawSome(_amount.sub(_balance));
_amount = _amount.add(_balance);
}
IERC20(token).safeTransfer(vault, _amount);
}
function _withdrawSome(uint256 _amount) internal returns (uint) {
For(fortube).withdrawUnderlying(token,_amount);
return _amount;
}
function harvest() public {
ForReward(fortube_reward).claimReward();
uint _forbal = IERC20(fortoken).balanceOf(address(this));
IERC20(fortoken).safeTransfer(governance, _forbal);
}
function balanceOf() public view returns (uint) {
return balanceOftoken()
.add(balanceOfPool());
}
function balanceOftoken() public view returns (uint) {
return IERC20(token).balanceOf(address(this));
}
function balanceOfPool() public view returns (uint) {
address _controller = For(fortube).controller();
IFToken fToken = IFToken(IBankController(_controller).getFTokeAddress(token));
return fToken.calcBalanceOfUnderlying(address(this));
}
}
| 250,890 | 10,790 |
994b5d5349b312c94a50d79800a9e6cfe7e61f48e6a6eb3bb447b3aa227fc869
| 26,186 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TUJbSe92jZtxXVkrgRG5jMNhM4aSf5kyro_EZY2ERN.sol
| 6,295 | 25,544 |
//SourceUnit: easyToEarn.sol
pragma solidity >=0.4.22 <0.7.0;
interface E2EToken {
function transferOwnership(address newOwner) external;
function stop() external;
function start() external;
function close() external;
function decimals() external view returns(uint256);
function symbol() external view returns(string memory);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function mint(address to, uint256 value) external returns (bool);
function increaseApproval(address spender, uint addedValue) external returns (bool);
function decreaseApproval(address spender, uint subtractedValue) external returns (bool);
function burn(uint256 _value) external;
function burnTokens(address who,uint256 _value) external;
}
contract EZY2ERN {
E2EToken public E2ECoin;
struct UserDetail {
uint id;
address referralAddress;
address currentReferrer;
uint totalIncome;
uint reinvestCount;
uint256 userCoins;
uint earnReferralCoins;
uint earnUserCoins;
uint coinAmount;
uint lostIncome;
uint totalCoinsWithdrawn;
uint totalRefCoinsWithdrawn;
uint referralCount;
mapping(uint => CycleData) cycleDetails;
mapping(uint => address []) levelReferrals;
}
struct CycleData {
uint cycleIncome;
uint investment;
uint Roi;
uint reffralIncome;
uint commision;
uint totalFundsWithdrawn;
uint poolIncome;
uint holdIncome;
uint totalWithDrawnIncome;
uint completedAt;
uint256 date;
bool isCompleted;
}
uint256 public decimals = 8;
uint256 public decimalFactor = 10 ** uint256(decimals);
address public owner;
address admin;
uint public userId;
uint public deploymentTime;
uint Days_In_Second = 43200;
uint day;
uint [] poolIncomeDetail;
uint [] comissionDetails;
uint freeIds = 13;
uint tokenDistributionLimit = 200000 * decimalFactor;
uint tokenDistributed;
uint withdrwanCoins;
mapping(address => UserDetail) public users;
mapping(uint => address) public idToAddress;
event Registration (address user,address referrer,uint userid,uint referrerid);
event ReInvestment (address user,address referrer,uint userid, uint investment,uint reinvestCount);
event RoiIncome(address user, address referrer, uint userId,uint amount,uint incomeLimit,uint reinvestCount);
event ReferBonus(address from, address reciever, uint amount, uint referrerReinvestCount);
event UserIncome(address from, address reciever, uint amount, uint referrerReinvestCount);
event NextPoolInvestment (uint nextPoolAmount);
event HoldIncome(address user,uint amount, uint reinvestCount);
event PoolIncome(address user, uint amount,uint reinvestCount);
event WithdrawnIncome(address user,uint userId,uint amount,uint reinvestCount,uint time);
event UserCoinBonus(address user, uint userId, uint coinAmount);
event ReferCoinBonus(address user, address referrer,uint amount);
event Donation(address user,uint amount);
event LostHoldIncome(address user,uint amount);
event HoldIncomeRecieved(address user,uint amount, uint reinvestCount);
event CoinsStatus(string,uint);
event NewUserPlaced(address user, address currentReferrer, address indexed referrerAddress, uint level, uint256 place);
event MatchingCommision(address user, address referrer, uint amount,uint level,uint reinvestCount);
modifier onlyOwner() {
require(msg.sender == admin,"Only owner have access to this function.");
_;
}
constructor(address ownerAddress, address adminAddress, address tokenAddress) public {
owner = ownerAddress;
admin = adminAddress;
E2ECoin = E2EToken(tokenAddress);
userId = 1;
users[owner].id = userId;
idToAddress[userId] = owner;
deploymentTime = now;
poolIncomeDetail = [30,20,15,10,8,5,4,4,2,2];
comissionDetails = [50,15,15,15,10,10,10,5,5,5];
emit Registration(owner,address(0),userId,uint(0));
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function depositPrice(uint count,uint penality) private view returns(bool) {
if(count == 1) {
require((msg.value >= 510 *1e6),'Amount should be greater than or equal to 100');
return true;
} else if(count > 1) {
require((msg.value >= (users[msg.sender].cycleDetails[count-1].investment + penality + 10 *1e6)),'Amount should be greater or equal than previous investment');
return true;
} else {
return false;
}
}
function investment(address referralAddress) external payable {
if(!isUserExists(msg.sender)) {
register(referralAddress);
} else {
uint currentCount = users[msg.sender].reinvestCount;
if(currentCount >0 && users[msg.sender].id > freeIds) {
require(users[msg.sender].cycleDetails[currentCount].isCompleted,'ouYou have not get 325% increment of your investment.');
}
}
investmentPrivate();
}
function register(address referralAddress) private{
require(users[referralAddress].reinvestCount>0,'Your referral have to do first investment first');
++userId;
users[msg.sender].id = userId;
users[msg.sender].referralAddress = referralAddress;
idToAddress[userId] = msg.sender;
emit Registration(msg.sender,referralAddress,users[msg.sender].id,users[referralAddress].id);
}
function investmentPrivate() private returns(bool) {
address referralAddress = users[msg.sender].referralAddress;
uint currentCount = users[msg.sender].reinvestCount;
if(currentCount > 0 && users[msg.sender].id > freeIds) {
require(users[msg.sender].cycleDetails[currentCount].isCompleted,'You have not get 325% increment of your investment.');
}
uint256 incomeLimit = ((users[msg.sender].cycleDetails[currentCount].investment)*325)/100;
uint hold;
if(users[msg.sender].cycleDetails[currentCount].cycleIncome > incomeLimit) {
hold = users[msg.sender].cycleDetails[currentCount].cycleIncome - incomeLimit;
}
uint penality;
uint diffDays;
if(users[msg.sender].reinvestCount>0 && users[msg.sender].id > freeIds) {
diffDays = (now - users[msg.sender].cycleDetails[currentCount].completedAt)/Days_In_Second;
if(diffDays > 4) {
penality = (diffDays - 4) * 25 *1e6;
}
}
uint gassFee;
if(users[msg.sender].id > 4) {
require(depositPrice(currentCount+1,penality),'Enter valid amount');
gassFee = 10 *1e6;
address(uint160(owner)).transfer(gassFee);
}
users[msg.sender].reinvestCount++;
if(currentCount>0 && users[msg.sender].id>freeIds) {
diffDays = (now - users[msg.sender].cycleDetails[currentCount].completedAt)/Days_In_Second;
if(diffDays <= 4) {
users[msg.sender].cycleDetails[users[msg.sender].reinvestCount].cycleIncome+= hold;
users[msg.sender].cycleDetails[users[msg.sender].reinvestCount].totalWithDrawnIncome+= hold;
emit HoldIncomeRecieved(msg.sender,hold,users[msg.sender].reinvestCount);
users[msg.sender].cycleDetails[currentCount].holdIncome = 0;
}
else {
emit LostHoldIncome(msg.sender,hold);
users[msg.sender].cycleDetails[currentCount].holdIncome = 0;
users[msg.sender].lostIncome+=hold;
}
}
if(users[msg.sender].id<=freeIds) {
users[msg.sender].cycleDetails[users[msg.sender].reinvestCount].cycleIncome+= users[msg.sender].cycleDetails[currentCount].totalWithDrawnIncome;
users[msg.sender].cycleDetails[users[msg.sender].reinvestCount].totalWithDrawnIncome+= users[msg.sender].cycleDetails[currentCount].totalWithDrawnIncome;
}
uint investAmount = msg.value - penality;
if(users[msg.sender].id <= 4) {
users[msg.sender].cycleDetails[users[msg.sender].reinvestCount].investment = 100000 *1e6;
users[msg.sender].cycleDetails[users[msg.sender].reinvestCount].date = now;
}
else {
users[msg.sender].cycleDetails[users[msg.sender].reinvestCount].investment = investAmount - gassFee;
users[msg.sender].cycleDetails[users[msg.sender].reinvestCount].date = now;
}
if(users[msg.sender].reinvestCount == 1) {
users[msg.sender].userCoins = ((users[msg.sender].cycleDetails[1].investment * 10)/100);
users[msg.sender].userCoins = (users[msg.sender].userCoins * decimalFactor)/10**6;
tokenDistributed += users[msg.sender].userCoins;
if(tokenDistributed >tokenDistributionLimit){
uint extra = tokenDistributed - tokenDistributionLimit;
tokenDistributed -= extra;
users[msg.sender].userCoins -= extra;
}
getFirstReferrer(msg.sender,referralAddress);
}
if(referralAddress != address(0)) {
sendRewards(referralAddress, msg.value - gassFee);
}
users[referralAddress].referralCount++;
emit ReInvestment(msg.sender,referralAddress,users[msg.sender].id,users[msg.sender].cycleDetails[users[msg.sender].reinvestCount].investment,users[msg.sender].reinvestCount);
return true;
}
function getFirstReferrer(address userAddress,address referrerAddress) public {
uint256 size;
address firstReferrer;
for (uint8 i=1; i<=10; i++) {
size = users[referrerAddress].levelReferrals[i].length;
if (i == 1 && size < 3) {
users[userAddress].currentReferrer = referrerAddress;
return updateMatrixGenealogy(userAddress, referrerAddress,referrerAddress);
}
if (size < 3 ** uint256(i)) {
if (i<=5) {
uint8 pos;
uint8 len;
uint8 minimum = 3;
for (uint8 j=0; j<(uint8(3)**(i-1)); j++) {
len = uint8(users[users[referrerAddress].levelReferrals[i-1][j]].levelReferrals[1].length);
if (len < minimum) {
minimum = len;
pos = j;
}
}
firstReferrer = users[referrerAddress].levelReferrals[i-1][pos];
users[userAddress].currentReferrer = firstReferrer;
return updateMatrixGenealogy(userAddress, firstReferrer, referrerAddress);
} else {
for (uint8 j=0; j<(uint8(3)**(i-1)); j++) {
if (users[users[referrerAddress].levelReferrals[i-1][j]].levelReferrals[1].length < 3) {
firstReferrer = users[referrerAddress].levelReferrals[i-1][j];
users[userAddress].currentReferrer = firstReferrer;
return updateMatrixGenealogy(userAddress, firstReferrer, referrerAddress);
}
}
}
}
}
}
function updateMatrixGenealogy(address userAddress, address referrerAddress, address parent) private {
address user = userAddress;
uint index;
uint256 place;
for (uint i=1; i<=10; i++) {
if (referrerAddress != address(0)) {
users[referrerAddress].levelReferrals[i].push(userAddress);
if (i<=3) {
for(uint j=0;j<=users[referrerAddress].levelReferrals[1].length-1;j++){
if(user == users[referrerAddress].levelReferrals[1][j]){
index=j+1;
}
}
place += (3**(i-1) * (index-1));
if(i-1 == 0){
place++;
}
emit NewUserPlaced(userAddress, referrerAddress, parent, i, place);
user = referrerAddress;
}
else{
emit NewUserPlaced(userAddress, referrerAddress, parent, i, 0);
}
referrerAddress = users[referrerAddress].currentReferrer;
}
}
}
function matchingCommision(uint amount,address userAddress)private {
address currentReferrer = users[userAddress].currentReferrer;
for(uint i=0; i<10; i++) {
if(currentReferrer == address(0)) {
return;
}
else {
if(users[currentReferrer].referralCount >= i+1 || currentReferrer == owner) {
uint balance = (amount * comissionDetails[i])/100;
users[currentReferrer].cycleDetails[users[currentReferrer].reinvestCount].commision += balance;
users[currentReferrer].cycleDetails[users[currentReferrer].reinvestCount].cycleIncome += balance;
users[currentReferrer].cycleDetails[users[currentReferrer].reinvestCount].totalWithDrawnIncome += balance;
emit MatchingCommision(userAddress,currentReferrer,balance,i+1,users[currentReferrer].reinvestCount);
uint256 incomeLimit = ((users[currentReferrer].cycleDetails[users[currentReferrer].reinvestCount].investment)*325)/100;
if(users[currentReferrer].cycleDetails[users[currentReferrer].reinvestCount].isCompleted) {
if(users[currentReferrer].cycleDetails[users[currentReferrer].reinvestCount].cycleIncome > incomeLimit) {
uint hold = users[currentReferrer].cycleDetails[users[currentReferrer].reinvestCount].cycleIncome - incomeLimit;
users[currentReferrer].cycleDetails[users[currentReferrer].reinvestCount].holdIncome = hold;
emit HoldIncome(currentReferrer,hold,users[currentReferrer].reinvestCount);
}
}
}
}
currentReferrer = users[currentReferrer].currentReferrer;
}
}
function getCycleDetails(uint cycle) public view returns (uint roi,uint reffralIncome,uint totalWithDrawnIncome, uint cycleIncome,uint holdIncome) {
return (users[msg.sender].cycleDetails[cycle].Roi,users[msg.sender].cycleDetails[cycle].reffralIncome,users[msg.sender].cycleDetails[cycle].totalWithDrawnIncome,users[msg.sender].cycleDetails[cycle].cycleIncome,users[msg.sender].cycleDetails[cycle].holdIncome);
}
function DailyTopSponserPool(address [] memory topPoolUsers,uint160 totalInvestment) public payable onlyOwner() {
require(topPoolUsers.length > 0,'No user register in last 12 hour');
require(totalInvestment > 0, 'Total investment of top pool users can not zero');
uint poolIncome = (totalInvestment * 3)/100;
uint distributeIncome = (poolIncome * 10)/100;
uint adminIncome = (poolIncome * 40)/100;
uint nextPoolIncome = (poolIncome * 50)/100;
for(uint k=0;k<10;k++) {
uint amount = (distributeIncome * poolIncomeDetail[k]) / 100;
if(k<=topPoolUsers.length-1) {
uint cycle = users[topPoolUsers[k]].reinvestCount;
users[topPoolUsers[k]].cycleDetails[cycle].poolIncome += amount;
users[topPoolUsers[k]].cycleDetails[cycle].cycleIncome += amount;
users[topPoolUsers[k]].cycleDetails[cycle].totalWithDrawnIncome += amount;
emit PoolIncome(topPoolUsers[k],amount,cycle);
uint256 incomeLimit = ((users[topPoolUsers[k]].cycleDetails[cycle].investment)*325)/100;
if(users[topPoolUsers[k]].cycleDetails[users[topPoolUsers[k]].reinvestCount].isCompleted) {
if(users[topPoolUsers[k]].cycleDetails[cycle].cycleIncome > incomeLimit) {
uint hold = users[topPoolUsers[k]].cycleDetails[cycle].cycleIncome - incomeLimit;
users[topPoolUsers[k]].cycleDetails[users[topPoolUsers[k]].reinvestCount].holdIncome = hold;
emit HoldIncome(topPoolUsers[k],hold,users[topPoolUsers[k]].reinvestCount);
}
}
}
else {
nextPoolIncome += amount;
}
}
address(uint160(owner)).transfer(adminIncome);
emit NextPoolInvestment(nextPoolIncome);
}
function Roi() private{
uint amount;
uint depositCount = users[msg.sender].reinvestCount;
require(depositCount > 0,'Please invest to get Roi income.');
uint256 incomeLimit = ((users[msg.sender].cycleDetails[depositCount].investment)*325)/100;
if(users[msg.sender].cycleDetails[depositCount].cycleIncome < incomeLimit) {
uint ROI = calculateROI(msg.sender,depositCount);
if(ROI > users[msg.sender].cycleDetails[depositCount].totalFundsWithdrawn){
amount= ROI- users[msg.sender].cycleDetails[depositCount].totalFundsWithdrawn;
if(address(this).balance < amount){
amount = address(this).balance;
}
}
users[msg.sender].cycleDetails[depositCount].totalFundsWithdrawn += amount;
users[msg.sender].cycleDetails[depositCount].Roi += amount;
users[msg.sender].cycleDetails[depositCount].cycleIncome += amount;
users[msg.sender].cycleDetails[depositCount].totalWithDrawnIncome += amount;
matchingCommision(amount,msg.sender);
emit RoiIncome (msg.sender,users[msg.sender].referralAddress,users[msg.sender].id,amount,incomeLimit,users[msg.sender].reinvestCount);
}
}
function getCoins()private{
uint COINS = calculateCoins(msg.sender);
if(COINS > users[msg.sender].userCoins) {
uint extra = COINS - users[msg.sender].userCoins;
COINS = COINS - extra;
}
if(COINS > users[msg.sender].totalCoinsWithdrawn) {
uint coins = COINS - users[msg.sender].totalCoinsWithdrawn;
uint coinBal = coinBalance();
if(coinBal < coins) {
coins = coinBal;
}
if(coinBal>0) {
E2ECoin.transfer(msg.sender,coins);
users[msg.sender].earnUserCoins += coins;
users[msg.sender].coinAmount += coins;
users[msg.sender].totalCoinsWithdrawn += coins;
withdrwanCoins += coins;
emit UserCoinBonus(msg.sender,users[msg.sender].id,coins);
}
if(users[msg.sender].referralAddress != address(0)){
uint coinBalnce = coinBalance();
uint refCoins = ((coins*10)/100);
if(coinBalnce < refCoins) {
refCoins = coinBalnce;
}
if(coinBal > 0) {
E2ECoin.transfer(users[msg.sender].referralAddress,refCoins);
users[users[msg.sender].referralAddress].coinAmount += ((coins*10)/100);
tokenDistributed += refCoins;
withdrwanCoins += refCoins;
emit ReferCoinBonus(msg.sender,users[msg.sender].referralAddress,((coins*10)/100));
}
}
}
else {
emit CoinsStatus('Coins Completed',users[msg.sender].earnUserCoins);
}
}
function calculateROI (address user, uint count) private view returns(uint value){
uint intrest = (users[user].cycleDetails[count].investment * 1)/100;
uint daysOver = ((now - users[user].cycleDetails[count].date)/Days_In_Second);
return daysOver * intrest;
}
function calculateCoins(address user) private view returns(uint coin) {
uint daysOver;
uint coins = ((users[user].userCoins)/100) ;
daysOver = ((now - users[user].cycleDetails[1].date)/Days_In_Second);
uint256 totalCoins = daysOver * coins;
return totalCoins;
}
function totalWithDrawn() public returns(bool) {
uint depositCount = users[msg.sender].reinvestCount;
uint256 incomeLimit = ((users[msg.sender].cycleDetails[depositCount].investment)*325)/100;
getCoins();
if((!users[msg.sender].cycleDetails[depositCount].isCompleted) && (users[msg.sender].id>freeIds)) {
Roi();
if(users[msg.sender].cycleDetails[depositCount].cycleIncome>=incomeLimit){
users[msg.sender].cycleDetails[depositCount].isCompleted = true;
users[msg.sender].cycleDetails[depositCount].holdIncome = users[msg.sender].cycleDetails[depositCount].cycleIncome - incomeLimit;
users[msg.sender].cycleDetails[depositCount].completedAt = now;
emit HoldIncome(msg.sender,users[msg.sender].cycleDetails[depositCount].holdIncome,users[msg.sender].reinvestCount);
users[msg.sender].cycleDetails[depositCount].totalWithDrawnIncome = users[msg.sender].cycleDetails[depositCount].totalWithDrawnIncome - users[msg.sender].cycleDetails[depositCount].holdIncome;
}
address(uint160(msg.sender)).transfer(users[msg.sender].cycleDetails[depositCount].totalWithDrawnIncome);
users[msg.sender].totalIncome += users[msg.sender].cycleDetails[depositCount].totalWithDrawnIncome;
emit WithdrawnIncome(msg.sender,users[msg.sender].id,users[msg.sender].cycleDetails[depositCount].totalWithDrawnIncome,depositCount,users[msg.sender].cycleDetails[depositCount].completedAt);
users[msg.sender].cycleDetails[depositCount].totalWithDrawnIncome = 0;
}
if(users[msg.sender].id<=freeIds) {
if((!users[msg.sender].cycleDetails[depositCount].isCompleted)) {
Roi();
if(users[msg.sender].cycleDetails[depositCount].cycleIncome >= incomeLimit){
users[msg.sender].cycleDetails[depositCount].isCompleted = true;
users[msg.sender].cycleDetails[depositCount].completedAt = now;
}
}
address(uint160(msg.sender)).transfer(users[msg.sender].cycleDetails[depositCount].totalWithDrawnIncome);
users[msg.sender].totalIncome += users[msg.sender].cycleDetails[depositCount].totalWithDrawnIncome;
emit WithdrawnIncome(msg.sender,users[msg.sender].id,users[msg.sender].cycleDetails[depositCount].totalWithDrawnIncome,depositCount,users[msg.sender].cycleDetails[depositCount].completedAt);
users[msg.sender].cycleDetails[depositCount].totalWithDrawnIncome = 0;
}
return true;
}
function sendRewards(address referralAddress, uint total) private {
uint amount = (total)* 15/100;
uint256 incomeLimit = ((users[msg.sender].cycleDetails[users[referralAddress].reinvestCount].investment)*325)/100;
users[referralAddress].cycleDetails[users[referralAddress].reinvestCount].reffralIncome += amount;
users[referralAddress].cycleDetails[users[referralAddress].reinvestCount].cycleIncome += amount;
users[referralAddress].cycleDetails[users[referralAddress].reinvestCount].totalWithDrawnIncome += amount;
users[referralAddress].totalIncome += amount;
if(users[referralAddress].cycleDetails[users[referralAddress].reinvestCount].isCompleted) {
if(users[referralAddress].cycleDetails[users[referralAddress].reinvestCount].cycleIncome > incomeLimit) {
uint hold = users[referralAddress].cycleDetails[users[referralAddress].reinvestCount].cycleIncome - incomeLimit;
users[referralAddress].cycleDetails[users[referralAddress].reinvestCount].holdIncome = hold;
emit HoldIncome(referralAddress,hold,users[referralAddress].reinvestCount);
}
}
emit ReferBonus(msg.sender,referralAddress,amount,users[referralAddress].reinvestCount);
}
function coinBalance () public view returns(uint) {
return E2ECoin.balanceOf(address(this));
}
function contractBalance () public view returns (uint) {
return address(this).balance;
}
function donation() public payable {
require(msg.value>0,'Amount can not be zero');
emit Donation(msg.sender,msg.value);
}
}
| 302,922 | 10,791 |
06af7d2e5b425c3b6db3e8c13f696307b43fa291d13084586418c7f0e67efd6c
| 27,430 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0x39B5B0dd442703Ea6D95bC52A73a42C20852c69a.sol
| 7,721 | 25,617 |
pragma solidity ^0.4.24;
contract owned {
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;
}
}
/// @title PONZIMOON
contract ponzimoon is owned {
using SafeMath for uint256;
Spaceship[] spaceships;
Player[] players;
mapping(address => uint256) addressMPid;
mapping(uint256 => address) pidXAddress;
mapping(string => uint256) nameXPid;
uint256 playerCount;
uint256 totalTicketCount;
uint256 airdropPrizePool;
uint256 moonPrizePool;
uint256 lotteryTime;
uint256 editPlayerNamePrice = 0.01 ether;
uint256 spaceshipPrice = 0.01 ether;
uint256 addSpaceshipPrice = 0.00000001 ether;
address maxAirDropAddress;
uint256 maxTotalTicket;
uint256 round;
uint256 totalDividendEarnings;
uint256 totalEarnings;
uint256 luckyPayerId;
struct Spaceship {
uint256 id;
string name;
uint256 speed;
address captain;
uint256 ticketCount;
uint256 dividendRatio;
uint256 spaceshipPrice;
uint256 addSpeed;
}
struct Player {
address addr;
string name;
uint256 earnings;
uint256 ticketCount;
uint256 dividendRatio;
uint256 distributionEarnings;
uint256 dividendEarnings;
uint256 withdrawalAmount;
uint256 parentId;
uint256 dlTicketCount;
uint256 xzTicketCount;
uint256 jcTicketCount;
}
constructor() public {
lotteryTime = now + 12 hours;
round = 1;
spaceships.push(Spaceship(0, "dalao", 100000, msg.sender, 0, 20, 15 ether, 2));
spaceships.push(Spaceship(1, "xiaozhuang", 100000, msg.sender, 0, 50, 15 ether, 5));
spaceships.push(Spaceship(2, "jiucai", 100000, msg.sender, 0, 80, 15 ether, 8));
uint256 playerArrayIndex = players.push(Player(msg.sender, "system", 0, 0, 3, 0, 0, 0, 0, 0, 0, 0));
addressMPid[msg.sender] = playerArrayIndex;
pidXAddress[playerArrayIndex] = msg.sender;
playerCount = players.length;
nameXPid["system"] = playerArrayIndex;
}
function getSpaceship(uint256 _spaceshipId) public view returns (uint256 _id,
string _name,
uint256 _speed,
address _captain,
uint256 _ticketCount,
uint256 _dividendRatio,
uint256 _spaceshipPrice){
_id = spaceships[_spaceshipId].id;
_name = spaceships[_spaceshipId].name;
_speed = spaceships[_spaceshipId].speed;
_captain = spaceships[_spaceshipId].captain;
_ticketCount = spaceships[_spaceshipId].ticketCount;
_dividendRatio = spaceships[_spaceshipId].dividendRatio;
_spaceshipPrice = spaceships[_spaceshipId].spaceshipPrice;
}
function getNowTime() public view returns (uint256){
return now;
}
function checkName(string _name) public view returns (bool){
if (nameXPid[_name] == 0) {
return false;
}
return true;
}
function setYxName(address _address, string _name) external onlyOwner {
if (addressMPid[_address] == 0) {
uint256 playerArrayIndex = players.push(Player(_address, _name, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
addressMPid[_address] = playerArrayIndex;
pidXAddress[playerArrayIndex] = _address;
playerCount = players.length;
nameXPid[_name] = playerArrayIndex;
} else {
uint256 _pid = addressMPid[_address];
Player storage _p = players[_pid.sub(1)];
_p.name = _name;
nameXPid[_name] = _pid;
}
}
function setName(string _name) external payable {
require(msg.value >= editPlayerNamePrice);
if (addressMPid[msg.sender] == 0) {
uint256 playerArrayIndex = players.push(Player(msg.sender, _name, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
addressMPid[msg.sender] = playerArrayIndex;
pidXAddress[playerArrayIndex] = msg.sender;
playerCount = players.length;
nameXPid[_name] = playerArrayIndex;
} else {
uint256 _pid = addressMPid[msg.sender];
Player storage _p = players[_pid.sub(1)];
_p.name = _name;
nameXPid[_name] = _pid;
}
Player storage _sysP = players[0];
_sysP.earnings = _sysP.earnings.add(msg.value);
_sysP.distributionEarnings = _sysP.distributionEarnings.add(msg.value);
}
function _computePayMoney(uint256 _ticketCount, address _addr) private view returns (bool){
uint256 _initMoney = 0.01 ether;
uint256 _eachMoney = 0.0001 ether;
uint256 _payMoney = (spaceshipPrice.mul(_ticketCount)).add(addSpaceshipPrice.mul((_ticketCount.sub(1))));
_payMoney = _payMoney.sub((_eachMoney.mul(_ticketCount)));
uint256 _tmpPid = addressMPid[_addr];
Player memory _p = players[_tmpPid.sub(1)];
if (_p.earnings >= (_initMoney.mul(_ticketCount)) && _p.earnings >= _payMoney) {
return true;
}
return false;
}
function checkTicket(uint256 _ticketCount, uint256 _money) private view returns (bool){
uint256 _initMoney = 0.01 ether;
uint256 _eachMoney = 0.0001 ether;
uint256 _payMoney = (spaceshipPrice.mul(_ticketCount)).add(addSpaceshipPrice.mul((_ticketCount.sub(1))));
_payMoney = _payMoney.sub((_eachMoney.mul(_ticketCount)));
if (_money >= (_initMoney.mul(_ticketCount)) && _money >= _payMoney) {
return true;
}
return false;
}
function checkNewPlayer(address _player) private {
if (addressMPid[_player] == 0) {
uint256 playerArrayIndex = players.push(Player(_player, "", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
addressMPid[_player] = playerArrayIndex;
pidXAddress[playerArrayIndex] = _player;
playerCount = players.length;
}
}
function addTicket(uint256 _ticketCount, uint256 _spaceshipNo, uint256 _pid) private {
spaceshipPrice = spaceshipPrice.add(addSpaceshipPrice.mul(_ticketCount));
totalTicketCount = totalTicketCount.add(_ticketCount);
Player storage _p = players[_pid.sub(1)];
_p.ticketCount = _p.ticketCount.add(_ticketCount);
if (_spaceshipNo == 0) {
_p.dlTicketCount = _p.dlTicketCount.add(_ticketCount);
Spaceship storage _s = spaceships[0];
_s.ticketCount = _s.ticketCount.add(_ticketCount);
_s.speed = _s.speed.add(_ticketCount.mul(_s.addSpeed));
}
if (_spaceshipNo == 1) {
_p.xzTicketCount = _p.xzTicketCount.add(_ticketCount);
Spaceship storage _s1 = spaceships[1];
_s1.ticketCount = _s1.ticketCount.add(_ticketCount);
_s1.speed = _s1.speed.add(_ticketCount.mul(_s1.addSpeed));
}
if (_spaceshipNo == 2) {
_p.jcTicketCount = _p.jcTicketCount.add(_ticketCount);
Spaceship storage _s2 = spaceships[2];
_s2.ticketCount = _s2.ticketCount.add(_ticketCount);
_s2.speed = _s2.speed.add(_ticketCount.mul(_s2.addSpeed));
}
}
function _payTicketByEarnings(uint256 _ticketCount, address _addr) private returns (uint256){
uint256 _tmpPid = addressMPid[_addr];
Player storage _p = players[_tmpPid.sub(1)];
uint256 _tmpMoney = spaceshipPrice.mul(_ticketCount);
uint256 _tmpMoney2 = addSpaceshipPrice.mul(_ticketCount.sub(1));
uint256 _returnMoney = _tmpMoney.add(_tmpMoney2);
_p.earnings = _p.earnings.sub(_returnMoney);
return _returnMoney;
}
function buyTicketByEarnings(uint256 _ticketCount, uint256 _spaceshipNo, string _name) external {
require(now < lotteryTime);
require(_spaceshipNo == 0 || _spaceshipNo == 1 || _spaceshipNo == 2);
require(addressMPid[msg.sender] != 0);
require(_computePayMoney(_ticketCount, msg.sender));
updateTime();
uint256 _money = _payTicketByEarnings(_ticketCount, msg.sender);
totalEarnings = totalEarnings.add(_money);
Player storage _p = players[addressMPid[msg.sender].sub(1)];
if (_p.parentId == 0 && nameXPid[_name] != 0) {
_p.parentId = nameXPid[_name];
}
luckyPayerId = addressMPid[msg.sender];
addTicket(_ticketCount, _spaceshipNo, addressMPid[msg.sender]);
addSpaceshipMoney(_money.div(100).mul(1));
Player storage _player = players[0];
uint256 _SysMoney = _money.div(100).mul(5);
_player.earnings = _player.earnings.add(_SysMoney);
_player.dividendEarnings = _player.dividendEarnings.add(_SysMoney);
uint256 _distributionMoney = _money.div(100).mul(10);
if (_p.parentId == 0) {
_player.earnings = _player.earnings.add(_distributionMoney);
_player.distributionEarnings = _player.distributionEarnings.add(_distributionMoney);
} else {
Player storage _player_ = players[_p.parentId.sub(1)];
_player_.earnings = _player_.earnings.add(_distributionMoney);
_player_.distributionEarnings = _player_.distributionEarnings.add(_distributionMoney);
}
if (_ticketCount > maxTotalTicket) {
maxTotalTicket = _ticketCount;
maxAirDropAddress = msg.sender;
}
uint256 _airDropMoney = _money.div(100).mul(2);
airdropPrizePool = airdropPrizePool.add(_airDropMoney);
if (airdropPrizePool >= 1 ether) {
Player storage _playerAirdrop = players[addressMPid[maxAirDropAddress].sub(1)];
_playerAirdrop.earnings = _playerAirdrop.earnings.add(airdropPrizePool);
_playerAirdrop.dividendEarnings = _playerAirdrop.dividendEarnings.add(airdropPrizePool);
airdropPrizePool = 0;
}
uint256 _remainderMoney = _cMoney(_money, _SysMoney, _distributionMoney, _airDropMoney);
updateGameMoney(_remainderMoney, _spaceshipNo, _ticketCount, addressMPid[msg.sender].sub(1));
}
function _cMoney(uint256 _money, uint256 _SysMoney, uint256 _distributionMoney, uint256 _airDropMoney)
private pure returns (uint256){
uint256 _czSpaceshipMoney = _money.div(100).mul(1).mul(3);
return _money.sub(_czSpaceshipMoney).sub(_SysMoney).
sub(_distributionMoney).sub(_airDropMoney);
}
function updateTime() private {
if (totalTicketCount < 50000) {
lotteryTime = now + 12 hours;
} else {
lotteryTime = now + 1 hours;
}
}
function buyTicket(uint256 _ticketCount, uint256 _spaceshipNo, string _name) external payable {
require(now < lotteryTime);
require(_spaceshipNo == 0 || _spaceshipNo == 1 || _spaceshipNo == 2);
require(checkTicket(_ticketCount, msg.value));
checkNewPlayer(msg.sender);
updateTime();
totalEarnings = totalEarnings.add(msg.value);
Player storage _p = players[addressMPid[msg.sender].sub(1)];
if (_p.parentId == 0 && nameXPid[_name] != 0) {
_p.parentId = nameXPid[_name];
}
luckyPayerId = addressMPid[msg.sender];
addTicket(_ticketCount, _spaceshipNo, addressMPid[msg.sender]);
addSpaceshipMoney(msg.value.div(100).mul(1));
Player storage _player = players[0];
uint256 _SysMoney = msg.value.div(100).mul(5);
_player.earnings = _player.earnings.add(_SysMoney);
_player.dividendEarnings = _player.dividendEarnings.add(_SysMoney);
uint256 _distributionMoney = msg.value.div(100).mul(10);
if (_p.parentId == 0) {
_player.earnings = _player.earnings.add(_distributionMoney);
_player.distributionEarnings = _player.distributionEarnings.add(_distributionMoney);
} else {
Player storage _player_ = players[_p.parentId.sub(1)];
_player_.earnings = _player_.earnings.add(_distributionMoney);
_player_.distributionEarnings = _player_.distributionEarnings.add(_distributionMoney);
}
if (_ticketCount > maxTotalTicket) {
maxTotalTicket = _ticketCount;
maxAirDropAddress = msg.sender;
}
uint256 _airDropMoney = msg.value.div(100).mul(2);
airdropPrizePool = airdropPrizePool.add(_airDropMoney);
if (airdropPrizePool >= 1 ether) {
Player storage _playerAirdrop = players[addressMPid[maxAirDropAddress].sub(1)];
_playerAirdrop.earnings = _playerAirdrop.earnings.add(airdropPrizePool);
_playerAirdrop.dividendEarnings = _playerAirdrop.dividendEarnings.add(airdropPrizePool);
airdropPrizePool = 0;
}
uint256 _remainderMoney = msg.value.sub((msg.value.div(100).mul(1)).mul(3)).sub(_SysMoney).
sub(_distributionMoney).sub(_airDropMoney);
updateGameMoney(_remainderMoney, _spaceshipNo, _ticketCount, addressMPid[msg.sender].sub(1));
}
function getFhMoney(uint256 _spaceshipNo, uint256 _money, uint256 _ticketCount, uint256 _targetNo) private view returns (uint256){
Spaceship memory _fc = spaceships[_spaceshipNo];
if (_spaceshipNo == _targetNo) {
uint256 _Ticket = _fc.ticketCount.sub(_ticketCount);
if (_Ticket == 0) {
return 0;
}
return _money.div(_Ticket);
} else {
if (_fc.ticketCount == 0) {
return 0;
}
return _money.div(_fc.ticketCount);
}
}
function updateGameMoney(uint256 _money, uint256 _spaceshipNo, uint256 _ticketCount, uint256 _arrayPid) private {
uint256 _lastMoney = addMoonPrizePool(_money, _spaceshipNo);
uint256 _dlMoney = _lastMoney.div(100).mul(53);
uint256 _xzMoney = _lastMoney.div(100).mul(33);
uint256 _jcMoney = _lastMoney.sub(_dlMoney).sub(_xzMoney);
uint256 _dlFMoney = getFhMoney(0, _dlMoney, _ticketCount, _spaceshipNo);
uint256 _xzFMoney = getFhMoney(1, _xzMoney, _ticketCount, _spaceshipNo);
uint256 _jcFMoney = getFhMoney(2, _jcMoney, _ticketCount, _spaceshipNo);
_fhMoney(_dlFMoney, _xzFMoney, _jcFMoney, _arrayPid, _spaceshipNo, _ticketCount);
}
function _fhMoney(uint256 _dlFMoney, uint256 _xzFMoney, uint256 _jcFMoney, uint256 arrayPid, uint256 _spaceshipNo, uint256 _ticketCount) private {
for (uint i = 0; i < players.length; i++) {
Player storage _tmpP = players[i];
uint256 _totalMoney = 0;
if (arrayPid != i) {
_totalMoney = _totalMoney.add(_tmpP.dlTicketCount.mul(_dlFMoney));
_totalMoney = _totalMoney.add(_tmpP.xzTicketCount.mul(_xzFMoney));
_totalMoney = _totalMoney.add(_tmpP.jcTicketCount.mul(_jcFMoney));
} else {
if (_spaceshipNo == 0) {
_totalMoney = _totalMoney.add((_tmpP.dlTicketCount.sub(_ticketCount)).mul(_dlFMoney));
} else {
_totalMoney = _totalMoney.add(_tmpP.dlTicketCount.mul(_dlFMoney));
}
if (_spaceshipNo == 1) {
_totalMoney = _totalMoney.add((_tmpP.xzTicketCount.sub(_ticketCount)).mul(_xzFMoney));
} else {
_totalMoney = _totalMoney.add(_tmpP.xzTicketCount.mul(_xzFMoney));
}
if (_spaceshipNo == 2) {
_totalMoney = _totalMoney.add((_tmpP.jcTicketCount.sub(_ticketCount)).mul(_jcFMoney));
} else {
_totalMoney = _totalMoney.add(_tmpP.jcTicketCount.mul(_jcFMoney));
}
}
_tmpP.earnings = _tmpP.earnings.add(_totalMoney);
_tmpP.dividendEarnings = _tmpP.dividendEarnings.add(_totalMoney);
}
}
function addMoonPrizePool(uint256 _money, uint256 _spaceshipNo) private returns (uint){
uint256 _tmpMoney;
if (_spaceshipNo == 0) {
_tmpMoney = _money.div(100).mul(80);
totalDividendEarnings = totalDividendEarnings.add((_money.sub(_tmpMoney)));
}
if (_spaceshipNo == 1) {
_tmpMoney = _money.div(100).mul(50);
totalDividendEarnings = totalDividendEarnings.add((_money.sub(_tmpMoney)));
}
if (_spaceshipNo == 2) {
_tmpMoney = _money.div(100).mul(20);
totalDividendEarnings = totalDividendEarnings.add((_money.sub(_tmpMoney)));
}
moonPrizePool = moonPrizePool.add(_tmpMoney);
return _money.sub(_tmpMoney);
}
function addSpaceshipMoney(uint256 _money) internal {
Spaceship storage _spaceship0 = spaceships[0];
uint256 _pid0 = addressMPid[_spaceship0.captain];
Player storage _player0 = players[_pid0.sub(1)];
_player0.earnings = _player0.earnings.add(_money);
_player0.dividendEarnings = _player0.dividendEarnings.add(_money);
Spaceship storage _spaceship1 = spaceships[1];
uint256 _pid1 = addressMPid[_spaceship1.captain];
Player storage _player1 = players[_pid1.sub(1)];
_player1.earnings = _player1.earnings.add(_money);
_player1.dividendEarnings = _player1.dividendEarnings.add(_money);
Spaceship storage _spaceship2 = spaceships[2];
uint256 _pid2 = addressMPid[_spaceship2.captain];
Player storage _player2 = players[_pid2.sub(1)];
_player2.earnings = _player2.earnings.add(_money);
_player2.dividendEarnings = _player2.dividendEarnings.add(_money);
}
function getPlayerInfo(address _playerAddress) public view returns (address _addr,
string _name,
uint256 _earnings,
uint256 _ticketCount,
uint256 _dividendEarnings,
uint256 _distributionEarnings,
uint256 _dlTicketCount,
uint256 _xzTicketCount,
uint256 _jcTicketCount){
uint256 _pid = addressMPid[_playerAddress];
Player storage _player = players[_pid.sub(1)];
_addr = _player.addr;
_name = _player.name;
_earnings = _player.earnings;
_ticketCount = _player.ticketCount;
_dividendEarnings = _player.dividendEarnings;
_distributionEarnings = _player.distributionEarnings;
_dlTicketCount = _player.dlTicketCount;
_xzTicketCount = _player.xzTicketCount;
_jcTicketCount = _player.jcTicketCount;
}
function addSystemUserEarnings(uint256 _money) private {
Player storage _player = players[0];
_player.earnings = _player.earnings.add(_money);
}
function withdraw() public {
require(addressMPid[msg.sender] != 0);
Player storage _player = players[addressMPid[msg.sender].sub(1)];
_player.addr.transfer(_player.earnings);
_player.withdrawalAmount = _player.withdrawalAmount.add(_player.earnings);
_player.earnings = 0;
_player.distributionEarnings = 0;
_player.dividendEarnings = 0;
}
function makeMoney() public {
require(now > lotteryTime);
uint256 _pMoney = moonPrizePool.div(2);
Player storage _luckyPayer = players[luckyPayerId.sub(1)];
_luckyPayer.earnings = _luckyPayer.earnings.add(_pMoney);
uint256 _nextMoonPrizePool = moonPrizePool.div(100).mul(2);
uint256 _luckyCaptainMoney = moonPrizePool.div(100).mul(5);
uint256 _luckyCrewMoney = moonPrizePool.sub(_nextMoonPrizePool).sub(_luckyCaptainMoney).sub(_pMoney);
uint256 _no1Spaceship = getFastestSpaceship();
Spaceship storage _s = spaceships[_no1Spaceship];
uint256 _pid = addressMPid[_s.captain];
Player storage _pPayer = players[_pid.sub(1)];
_pPayer.earnings = _pPayer.earnings.add(_luckyCaptainMoney);
uint256 _eachMoney = _getLuckySpaceshipMoney(_no1Spaceship, _luckyCrewMoney);
for (uint i = 0; i < players.length; i++) {
Player storage _tmpP = players[i];
if (_no1Spaceship == 0) {
_tmpP.earnings = _tmpP.earnings.add(_tmpP.dlTicketCount.mul(_eachMoney));
_tmpP.dividendEarnings = _tmpP.dividendEarnings.add(_tmpP.dlTicketCount.mul(_eachMoney));
}
if (_no1Spaceship == 1) {
_tmpP.earnings = _tmpP.earnings.add(_tmpP.xzTicketCount.mul(_eachMoney));
_tmpP.dividendEarnings = _tmpP.dividendEarnings.add(_tmpP.xzTicketCount.mul(_eachMoney));
}
if (_no1Spaceship == 2) {
_tmpP.earnings = _tmpP.earnings.add(_tmpP.jcTicketCount.mul(_eachMoney));
_tmpP.dividendEarnings = _tmpP.dividendEarnings.add(_tmpP.jcTicketCount.mul(_eachMoney));
}
_tmpP.dlTicketCount = 0;
_tmpP.xzTicketCount = 0;
_tmpP.jcTicketCount = 0;
_tmpP.ticketCount = 0;
}
_initSpaceship();
totalTicketCount = 0;
airdropPrizePool = 0;
moonPrizePool = _nextMoonPrizePool;
lotteryTime = now + 12 hours;
spaceshipPrice = 0.01 ether;
maxAirDropAddress = pidXAddress[1];
maxTotalTicket = 0;
round = round.add(1);
luckyPayerId = 1;
}
function _initSpaceship() private {
for (uint i = 0; i < spaceships.length; i++) {
Spaceship storage _s = spaceships[i];
_s.captain = pidXAddress[1];
_s.ticketCount = 0;
_s.spaceshipPrice = 15 ether;
_s.speed = 100000;
}
}
function _getLuckySpaceshipMoney(uint256 _spaceshipId, uint256 _luckyMoney) private view returns (uint256){
Spaceship memory _s = spaceships[_spaceshipId];
uint256 _eachLuckyMoney = _luckyMoney.div(_s.ticketCount);
return _eachLuckyMoney;
}
function getFastestSpaceship() private view returns (uint256){
Spaceship memory _dlSpaceship = spaceships[0];
Spaceship memory _xzSpaceship = spaceships[1];
Spaceship memory _jcSpaceship = spaceships[2];
uint256 _maxSpeed;
if (_jcSpaceship.speed >= _xzSpaceship.speed) {
if (_jcSpaceship.speed >= _dlSpaceship.speed) {
_maxSpeed = 2;
} else {
_maxSpeed = 0;
}
} else {
if (_xzSpaceship.speed >= _dlSpaceship.speed) {
_maxSpeed = 1;
} else {
_maxSpeed = 0;
}
}
return _maxSpeed;
}
function getGameInfo() public view returns (uint256 _totalTicketCount,
uint256 _airdropPrizePool,
uint256 _moonPrizePool,
uint256 _lotteryTime,
uint256 _nowTime,
uint256 _spaceshipPrice,
uint256 _round,
uint256 _totalEarnings,
uint256 _totalDividendEarnings){
_totalTicketCount = totalTicketCount;
_airdropPrizePool = airdropPrizePool;
_moonPrizePool = moonPrizePool;
_lotteryTime = lotteryTime;
_nowTime = now;
_spaceshipPrice = spaceshipPrice;
_round = round;
_totalEarnings = totalEarnings;
_totalDividendEarnings = totalDividendEarnings;
}
function _updateSpaceshipPrice(uint256 _spaceshipId) internal {
spaceships[_spaceshipId].spaceshipPrice = spaceships[_spaceshipId].spaceshipPrice.add(spaceships[_spaceshipId].spaceshipPrice.mul(3).div(10));
}
function campaignCaptain(uint _spaceshipId) external payable {
require(now < lotteryTime);
require(msg.value == spaceships[_spaceshipId].spaceshipPrice);
if (addressMPid[msg.sender] == 0) {
uint256 playerArrayIndex = players.push(Player(msg.sender, "", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
addressMPid[msg.sender] = playerArrayIndex;
pidXAddress[playerArrayIndex] = msg.sender;
playerCount = players.length;
}
spaceships[_spaceshipId].captain.transfer(msg.value);
spaceships[_spaceshipId].captain = msg.sender;
_updateSpaceshipPrice(_spaceshipId);
}
}
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;
}
}
| 335,859 | 10,792 |
46e5264a2d4af0d3c22f81aa77f92dd0ada310f3369817baf0e65a6bf9cbc64e
| 14,423 |
.sol
|
Solidity
| false |
443054241
|
KarmaDAO/Contracts
|
dc754363ec8904b19e67ce7cdae8b2432cb17e80
|
mocks/BondHelper_lp.sol
| 3,460 | 12,545 |
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 MIN;
address public Karma; //
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 _KARMA, address _MIN, ITreasury _treasury) {
require(_deposit != address(0));
deposit = _deposit;
require(_KARMA != address(0));
Karma = _KARMA;
_tokenA = _KARMA;
require(_MIN != address(0));
MIN = _MIN;
_tokenB = _MIN;
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));
}
Karma.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(MIN, Karma, MIN.myBalance(), Karma.myBalance(), 0, 0, address(this), block.timestamp);
principle.safeApprove(address(deposit), moreLPAmount);
if (MIN.myBalance() > 0) {
MIN.safeTransfer(msg.sender, MIN.myBalance());
}
if (Karma.myBalance() > 0) {
Karma.safeTransfer(msg.sender, Karma.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(MIN, Karma));
(uint256 token0Reserve, uint256 token1Reserve,) = lpToken.getReserves();
(uint256 debtReserve, uint256 relativeReserve) = MIN ==
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 ? (Karma, MIN) : (MIN, Karma);
uint[] memory amounts = router.getAmountsOut(swapAmt, path);
(uint256 amount0, uint256 amount1) = MIN == 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);
}
}
| 20,282 | 10,793 |
9e9a658ae69acc239a9f4a2f06069ed4d1b0533b9add4440d4f753eb62859542
| 17,205 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTRKfXudaTmpqYNCHSkd475gSn5H7V98wf_GoldFinancex.sol
| 3,556 | 13,673 |
//SourceUnit: GoldFinanceX.sol
pragma solidity 0.5.10;
contract GoldFinancex {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 100;
uint constant public INVEST_MIN_AMOUNT = 100 trx;
uint constant public BASE_PERCENT = 500;
uint[] public REFERRAL_PERCENTS = [500, 200, 100, 50, 50];
uint constant public MARKETING_FEE = 500;
uint constant public FUND_FEE = 500;
uint constant public MAX_CONTRACT_PERCENT = 1500;
uint constant public MAX_HOLD_PERCENT = 1500;
uint constant public MAX_DEPOSIT_PERCENT = 1500;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 250000 trx;
uint constant public USER_DEPOSITS_STEP = 5000 trx;
uint constant public TIME_STEP = 1 days;
uint public totalDeposits;
uint public totalInvested;
uint public totalWithdrawn;
uint public contractPercent;
address payable public marketingAddress;
address payable public fundAddress;
struct Deposit {
uint64 amount;
uint64 withdrawn;
uint64 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[5] refs;
uint16 rbackPercent;
}
mapping (address => User) internal users;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event RefBack(address indexed referrer, address indexed referral, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable marketingAddr, address payable fundAddr) public {
require(!isContract(marketingAddr) && !isContract(fundAddr));
marketingAddress = marketingAddr;
fundAddress = fundAddr;
contractPercent = getContractBalanceRate();
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT, "Minimum deposit amount 100 TRX");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 100 deposits from address");
uint marketingFee = msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint fundFee = msg.value.mul(FUND_FEE).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
fundAddress.transfer(fundFee);
emit FeePayed(msg.sender, marketingFee.add(fundFee));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 5; i++) {
if (upline != address(0)) {
uint amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
if (i == 0 && users[upline].rbackPercent > 0) {
refbackAmount = amount.mul(uint(users[upline].rbackPercent)).div(PERCENTS_DIVIDER);
msg.sender.transfer(refbackAmount);
emit RefBack(upline, msg.sender, refbackAmount);
amount = amount.sub(refbackAmount);
}
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msg.value), 0, uint64(refbackAmount), uint32(block.timestamp)));
totalInvested = totalInvested.add(msg.value);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function setRefback(uint16 rbackPercent) public {
require(rbackPercent <= 10000);
User storage user = users[msg.sender];
if (user.deposits.length > 0) {
user.rbackPercent = rbackPercent;
}
}
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() internal view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(5));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getUserDepositRate(address userAddress) public view returns (uint) {
uint userDepositRate;
if (getUserAmountOfDeposits(userAddress) > 0) {
userDepositRate = getUserTotalDeposits(userAddress).div(USER_DEPOSITS_STEP).mul(10);
if (userDepositRate > MAX_DEPOSIT_PERCENT) {
userDepositRate = MAX_DEPOSIT_PERCENT;
}
}
return userDepositRate;
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint userDepositRate = getUserDepositRate(userAddress);
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(20);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier).add(userDepositRate);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn)).add(uint(user.deposits[i].refback));
}
return amount;
}
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
uint userDepositRate = getUserDepositRate(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn, userDepositRate);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint16, uint16, uint64, uint24[5] memory) {
User storage user = users[userAddress];
return (user.referrer, user.rbackPercent, users[user.referrer].rbackPercent, user.bonus, user.refs);
}
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;
}
}
| 287,350 | 10,794 |
547d3ff08147b36716980c8890887795971bf3d9e3019330d433eb3fdf51bbf5
| 34,203 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/1e/1EA118e43F92E0ec971574B974637261D7d75068_AicoreToken.sol
| 4,212 | 16,238 |
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity 0.6.6;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function 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 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;
}
}
abstract contract ERC20Capped is ERC20 {
using SafeMath for uint256;
uint256 private _cap;
constructor (uint256 cap_) internal {
require(cap_ > 0, "ERC20Capped: cap is 0");
_cap = cap_;
}
function cap() public view virtual returns (uint256) {
return _cap;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) { // When minting tokens
require(totalSupply().add(amount) <= cap(), "ERC20Capped: cap exceeded");
}
}
}
// File: AicoreToken.sol
// Token with Governance.
contract AicoreToken is ERC20Capped, Ownable {
using SafeMath for uint256;
constructor(string memory _name, string memory _symbol, uint256 _cap) ERC20(_name, _symbol) ERC20Capped(_cap) public {}
/// @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);
}
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;
}
}
| 47,304 | 10,795 |
8b0ce95ba1d4924c7910c33da2cb4142616e312e34def232c415f19bda7b902b
| 28,026 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x4e55C62f4e2ca19B22c2156273F5900e124B9acD.sol
| 2,919 | 11,464 |
pragma solidity 0.4.23;
contract AccessControlLight {
/// @notice Role manager is responsible for assigning the roles
/// @dev Role ROLE_ROLE_MANAGER allows modifying operator roles
uint256 private constant ROLE_ROLE_MANAGER = 0x10000000;
/// @notice Feature manager is responsible for enabling/disabling
/// global features of the smart contract
/// @dev Role ROLE_FEATURE_MANAGER allows modifying global features
uint256 private constant ROLE_FEATURE_MANAGER = 0x20000000;
/// @dev Bitmask representing all the possible permissions (super admin role)
uint256 private constant FULL_PRIVILEGES_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/// @dev A bitmask of globally enabled features
uint256 public features;
/// @notice Privileged addresses with defined roles/permissions
/// @notice In the context of ERC20/ERC721 tokens these can be permissions to
/// allow minting tokens, transferring on behalf and so on
/// @dev Maps an address to the permissions bitmask (role), where each bit
/// represents a permission
/// @dev Bitmask 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
/// represents all possible permissions
mapping(address => uint256) public userRoles;
/// @dev Fired in updateFeatures()
event FeaturesUpdated(address indexed _by, uint256 _requested, uint256 _actual);
/// @dev Fired in updateRole()
event RoleUpdated(address indexed _by, address indexed _to, uint256 _requested, uint256 _actual);
constructor() public {
// contract creator has full privileges
userRoles[msg.sender] = FULL_PRIVILEGES_MASK;
}
function updateFeatures(uint256 mask) public {
// caller must have a permission to update global features
require(isSenderInRole(ROLE_FEATURE_MANAGER));
// evaluate new features set and assign them
features = evaluateBy(msg.sender, features, mask);
// fire an event
emit FeaturesUpdated(msg.sender, mask, features);
}
function updateRole(address operator, uint256 role) public {
// caller must have a permission to update user roles
require(isSenderInRole(ROLE_ROLE_MANAGER));
// evaluate the role and reassign it
userRoles[operator] = evaluateBy(msg.sender, userRoles[operator], role);
// fire an event
emit RoleUpdated(msg.sender, operator, role, userRoles[operator]);
}
function evaluateBy(address operator, uint256 actual, uint256 required) public constant returns(uint256) {
// read operator's permissions
uint256 p = userRoles[operator];
// taking into account operator's permissions,
// 1) enable permissions requested on the `current`
actual |= p & required;
// 2) disable permissions requested on the `current`
actual &= FULL_PRIVILEGES_MASK ^ (p & (FULL_PRIVILEGES_MASK ^ required));
// return calculated result (actual is not modified)
return actual;
}
function isFeatureEnabled(uint256 required) public constant returns(bool) {
// delegate call to `__hasRole`, passing `features` property
return __hasRole(features, required);
}
function isSenderInRole(uint256 required) public constant returns(bool) {
// delegate call to `isOperatorInRole`, passing transaction sender
return isOperatorInRole(msg.sender, required);
}
function isOperatorInRole(address operator, uint256 required) public constant returns(bool) {
// delegate call to `__hasRole`, passing operator's permissions (role)
return __hasRole(userRoles[operator], required);
}
/// @dev Checks if role `actual` contains all the permissions required `required`
function __hasRole(uint256 actual, uint256 required) internal pure returns(bool) {
// check the bitmask for the role required and return the result
return actual & required == required;
}
}
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
// a variable to load `extcodesize` to
uint256 size = 0;
// 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.
// solium-disable-next-line security/no-inline-assembly
assembly {
// retrieve the size of the code at address `addr`
size := extcodesize(addr)
}
// positive size indicates a smart contract address
return size > 0;
}
}
interface ERC20Receiver {
function onERC20Received(address _operator, address _from, uint256 _value, bytes _data) external returns(bytes4);
}
contract GoldERC20 is AccessControlLight {
uint32 public constant TOKEN_VERSION = 0x300;
string public constant symbol = "GLD";
string public constant name = "GOLD - CryptoMiner World";
uint8 public constant decimals = 3;
uint256 public constant ONE_UNIT = uint256(10) ** decimals;
mapping(address => uint256) private tokenBalances;
uint256 private tokensTotal;
mapping(address => mapping(address => uint256)) private transferAllowances;
uint32 public constant FEATURE_TRANSFERS = 0x00000001;
uint32 public constant FEATURE_TRANSFERS_ON_BEHALF = 0x00000002;
uint32 public constant ROLE_TOKEN_CREATOR = 0x00000001;
uint32 public constant ROLE_TOKEN_DESTROYER = 0x00000002;
bytes4 private constant ERC20_RECEIVED = 0x4fc35859;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Minted(address indexed _by, address indexed _to, uint256 _value);
event Burnt(address indexed _by, address indexed _from, uint256 _value);
function totalSupply() public constant returns (uint256) {
// read total tokens value and return
return tokensTotal;
}
function balanceOf(address _owner) public constant returns (uint256) {
// read the balance from storage and return
return tokenBalances[_owner];
}
function allowance(address _owner, address _spender) public constant returns (uint256) {
// read the value from storage and return
return transferAllowances[_owner][_spender];
}
function transfer(address _to, uint256 _value) public returns (bool) {
// just delegate call to `transferFrom`,
// `FEATURE_TRANSFERS` is verified inside it
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
// just delegate call to `safeTransferFrom`, passing empty `_data`,
// `FEATURE_TRANSFERS` is verified inside it
safeTransferFrom(_from, _to, _value, "");
// `safeTransferFrom` throws of any error, so
// if we're here - it means operation successful,
// just return true
return true;
}
function safeTransferFrom(address _from, address _to, uint256 _value, bytes _data) public {
// first delegate call to `unsafeTransferFrom`
// to perform the unsafe token(s) transfer
unsafeTransferFrom(_from, _to, _value);
// after the successful transfer check if receiver supports
// ERC20Receiver and execute a callback handler `onERC20Received`,
// reverting whole transaction on any error:
// check if receiver `_to` supports ERC20Receiver interface
if (AddressUtils.isContract(_to)) {
// if `_to` is a contract execute onERC20Received
bytes4 response = ERC20Receiver(_to).onERC20Received(msg.sender, _from, _value, _data);
// expected response is ERC20_RECEIVED
require(response == ERC20_RECEIVED);
}
}
function unsafeTransferFrom(address _from, address _to, uint256 _value) public {
// if `_from` is equal to sender, require transfers feature to be enabled
// otherwise require transfers on behalf feature to be enabled
require(_from == msg.sender && isFeatureEnabled(FEATURE_TRANSFERS)
|| _from != msg.sender && isFeatureEnabled(FEATURE_TRANSFERS_ON_BEHALF));
// non-zero to address check
require(_to != address(0));
// sender and recipient cannot be the same
require(_from != _to);
// zero value transfer check
require(_value != 0);
// by design of mint() -
// - no need to make arithmetic overflow check on the _value
// in case of transfer on behalf
if(_from != msg.sender) {
// verify sender has an allowance to transfer amount of tokens requested
require(transferAllowances[_from][msg.sender] >= _value);
// decrease the amount of tokens allowed to transfer
transferAllowances[_from][msg.sender] -= _value;
}
// verify sender has enough tokens to transfer on behalf
require(tokenBalances[_from] >= _value);
// perform the transfer:
// decrease token owner (sender) balance
tokenBalances[_from] -= _value;
// increase `_to` address (receiver) balance
tokenBalances[_to] += _value;
// emit an ERC20 transfer event
emit Transfer(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public returns (bool) {
// perform an operation: write value requested into the storage
transferAllowances[msg.sender][_spender] = _value;
// emit an event
emit Approval(msg.sender, _spender, _value);
// operation successful, return true
return true;
}
function mint(address _to, uint256 _value) public {
// calculate native value, taking into account `decimals`
uint256 value = _value * ONE_UNIT;
// arithmetic overflow and non-zero value check
require(value > _value);
// delegate call to native `mintNative`
mintNative(_to, value);
}
function mintNative(address _to, uint256 _value) public {
// check if caller has sufficient permissions to mint tokens
require(isSenderInRole(ROLE_TOKEN_CREATOR));
// non-zero recipient address check
require(_to != address(0));
// non-zero _value and arithmetic overflow check on the total supply
// this check automatically secures arithmetic overflow on the individual balance
require(tokensTotal + _value > tokensTotal);
// increase `_to` address balance
tokenBalances[_to] += _value;
// increase total amount of tokens value
tokensTotal += _value;
// fire ERC20 compliant transfer event
emit Transfer(address(0), _to, _value);
// fire a mint event
emit Minted(msg.sender, _to, _value);
}
function burn(address _from, uint256 _value) public {
// calculate native value, taking into account `decimals`
uint256 value = _value * ONE_UNIT;
// arithmetic overflow and non-zero value check
require(value > _value);
// delegate call to native `burnNative`
burnNative(_from, value);
}
function burnNative(address _from, uint256 _value) public {
// check if caller has sufficient permissions to burn tokens
require(isSenderInRole(ROLE_TOKEN_DESTROYER));
// non-zero burn value check
require(_value != 0);
// verify `_from` address has enough tokens to destroy
// (basically this is a arithmetic overflow check)
require(tokenBalances[_from] >= _value);
// decrease `_from` address balance
tokenBalances[_from] -= _value;
// decrease total amount of tokens value
tokensTotal -= _value;
// fire ERC20 compliant transfer event
emit Transfer(_from, address(0), _value);
// fire a burn event
emit Burnt(msg.sender, _from, _value);
}
}
| 335,659 | 10,796 |
e6d635757abf632f71a2585abe2ecc78e0d00ba5d1fcedc1fa97396ee43f90ff
| 24,710 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/unlimitedCompilerVersions/manualCheck/0x12d288c45b7948a2dabd67c561dcce17605ade98_unlimitedCompilerVersions.sol
| 4,019 | 15,849 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.6; //inject UNLIMITED COMPILER VERSIONS
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(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
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;
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(_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 returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
contract YolexExchange {
using SafeMath for uint256;
address internal constant UNISWAP_ROUTER_ADDRESS = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 public uniswapRouter;
address owner;
address newOwner;
constructor() public {
owner = msg.sender;
uniswapRouter = IUniswapV2Router02(UNISWAP_ROUTER_ADDRESS);
}
modifier onlyOwner(){
require(msg.sender == owner, "permission failed");
_;
}
function getEstimatedETHforToken(uint _amount, address _tokenAddress) public view returns (uint[] memory) {
return uniswapRouter.getAmountsOut(_amount, getPathForETHtoToken(_tokenAddress));
}
function getPathForETHtoToken(address _tokenAddress) public view returns (address[] memory) {
address[] memory path = new address[](2);
path[0] = uniswapRouter.WETH();
path[1] = _tokenAddress;
return path;
}
function convertEthToToken(uint deadline, uint _amountOutMin, uint amountWithFees, address _tokenAddress) public payable returns(uint[] memory) {
uint[] memory result = uniswapRouter.swapExactETHForTokens{value: amountWithFees}(_amountOutMin, getPathForETHtoToken(_tokenAddress), msg.sender, deadline);
return result;
}
function convertEthToTokenSupportTokensWithFees(uint deadline, uint _amountOutMin, uint amountWithFees, address _tokenAddress) public payable returns(bool) {
uniswapRouter.swapExactETHForTokensSupportingFeeOnTransferTokens{value: amountWithFees}(_amountOutMin,
getPathForETHtoToken(_tokenAddress), msg.sender, deadline);
return true;
}
//.....................................................................................
function getPathForTokenToETH(address _tokenAddress) public view returns (address[] memory) {
address[] memory path = new address[](2);
path[0] = _tokenAddress;
path[1] = uniswapRouter.WETH();
return path;
}
function getEstimatedTokenToETH(uint _amount, address _tokenAddress) public view returns (uint[] memory) {
return uniswapRouter.getAmountsOut(_amount, getPathForTokenToETH(_tokenAddress));
}
function convertTokenToETH(uint deadline, uint _amountIn, uint _amountOutMin, address _tokenAddress, uint _allowedAmount, uint _amountWithFees) public returns(uint){
ERC20 token = ERC20(_tokenAddress);
uint allowance = token.allowance(address(this), UNISWAP_ROUTER_ADDRESS);
if (allowance < _amountIn) {
transferFromUserAccount(_amountIn, _tokenAddress);
token.approve(UNISWAP_ROUTER_ADDRESS, _allowedAmount);
uniswapRouter.swapExactTokensForETH(_amountWithFees, _amountOutMin, getPathForTokenToETH(_tokenAddress), msg.sender, deadline);
} else {
transferFromUserAccount(_amountIn, _tokenAddress);
uniswapRouter.swapExactTokensForETH(_amountWithFees, _amountOutMin, getPathForTokenToETH(_tokenAddress), msg.sender, deadline);
}
}
function convertTokenToEthSupportTokensWithFees(uint deadline, uint _amountIn, uint _amountOutMin, address _tokenAddress, uint _allowedAmount, uint _amountWithFees) public payable returns(bool) {
ERC20 token = ERC20(_tokenAddress);
uint allowance = token.allowance(address(this), UNISWAP_ROUTER_ADDRESS);
if (allowance < _amountIn) {
transferFromUserAccount(_amountIn, _tokenAddress);
token.approve(UNISWAP_ROUTER_ADDRESS, _allowedAmount);
uniswapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(_amountWithFees, _amountOutMin, getPathForTokenToETH(_tokenAddress), msg.sender, deadline);
} else {
transferFromUserAccount(_amountIn, _tokenAddress);
uniswapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(_amountWithFees, _amountOutMin, getPathForTokenToETH(_tokenAddress), msg.sender, deadline);
}
}
function transferFromUserAccount(uint _amountIn, address _tokenAddress) internal returns(bool){
ERC20 token = ERC20(_tokenAddress);
bool response = token.transferFrom(msg.sender, address(this), _amountIn);
return response;
}
function checkAllowance(address _spender, address _tokenAddress) external view returns(uint){
ERC20 token = ERC20(_tokenAddress);
uint allowed = token.allowance(msg.sender, _spender);
return allowed;
}
function assignOwner(address _newOwner) external onlyOwner returns(address){
newOwner = _newOwner;
return newOwner;
}
function acceptOwnership() external returns(address){
require(msg.sender == newOwner, "msg.sender should match newOwner");
owner = newOwner;
return owner;
}
function transferToWallet(uint _amount, address payable _receipient) external onlyOwner returns(bool){
_receipient.transfer(_amount);
return true;
}
function transferToWalletTokens(uint _amount, address _receipient, address _tokenAddress) external onlyOwner returns(bool){
ERC20 token = ERC20(_tokenAddress);
token.transfer(_receipient, _amount);
return true;
}
receive() payable external {}
}
| 277,494 | 10,797 |
3c911bd5b5114490c72926487cf232334f41482263c4f9b5f1a0a6e7519f7535
| 25,500 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x7704d0f51EeFe2A712ceCF87248c3B85D2Fb3eb7/library.sol
| 3,514 | 14,377 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
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);
}
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) {
// 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) {
// 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");
}
}
}
library Strings {
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);
uint256 index = digits - 1;
temp = value;
while (temp != 0) {
buffer[index--] = byte(uint8(48 + temp % 10));
temp /= 10;
}
return string(buffer);
}
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(uint80 _roundId)
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
function latestRoundData()
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
}
// CDF data contact interface
abstract contract CDFDataInterface {
mapping (uint => uint32[]) public CDF;
uint32[] public Durations;
uint public Amplifier;
function numDurations() external view virtual returns (uint);
}
interface IOption is IERC20 {
function resetOption(uint strikePrice_, uint newSupply) external;
function name() external view returns (string memory);
// previous rounds
function getRoundTotalSupply(uint r) external view returns(uint256);
function getRoundExpiryDate(uint r) external view returns(uint);
function getRoundStrikePrice(uint r) external view returns(uint);
function getRoundSettlePrice(uint r) external view returns(uint);
function getRoundTotalPremiums(uint r) external view returns(uint);
function getRoundBalanceOf(uint r, address account) external view returns (uint256);
function getRoundAccPremiumShare(uint r) external view returns(uint);
function setRoundAccPremiumShare(uint r, uint premiumShare) external;
function getUnclaimedProfitsRound(address account) external view returns (uint);
function setUnclaimedProfitsRound(uint r, address account) external;
function getSettledRound(address account) external view returns (uint);
function setSettledRound(uint r, address account) external;
function getRoundAccOPASellerShare(uint r) external view returns(uint);
function setRoundAccOPASellerShare(uint r, uint sellerOPAShare) external;
// current round
function addPremium(uint256 amountUSDT) external;
function totalPremiums() external view returns (uint);
function expiryDate() external view returns (uint);
function strikePrice() external view returns (uint);
function getRound() external view returns (uint);
function getDuration() external view returns (uint);
function getPool() external view returns (address);
}
interface IPoolerToken is IERC20 {
function mint(address account, uint256 amount) external;
function burn(address account, uint256 amount) external;
function getPool() external view returns (address);
}
interface IOptionPool {
function name() external view returns (string memory);
function owner() external view returns (address);
function transferOwnership(address newOwner) external;
function pausePooler() external;
function unpausePooler() external;
function pauseBuyer() external;
function unpauseBuyer() external;
function settlePooler(address account) external;
function settleBuyer(address account) external;
function update() external;
function optionsLeft(IOption optionContract) external view returns (uint256 left, uint round);
function buy(uint amount, IOption optionContract, uint round) external;
function premiumCost(uint amount, IOption optionContract) external view returns(uint);
function listOptions() external view returns (IOption []memory);
function currentUtilizationRate() external view returns (uint256);
function adjustSigma(uint16 newSigma) external;
function NWA() external view returns (uint);
function claimPremium() external;
function claimOPA() external;
function claimProfits() external;
function checkOPA(address account) external view returns(uint256 opa);
function checkPremium(address account) external view returns (uint256 premium);
function checkProfits(address account) external view returns (uint256 profits);
function setOPAToken(IERC20 OPAToken_) external;
function setPoolManager(address poolManager) external;
function setUtilizationRate(uint8 rate) external;
function setMaxUtilizationRate(uint8 maxrate) external;
function getNextUpdateTime() external view returns (uint);
}
interface IPandaFactory {
function createOption(uint duration_, uint8 decimals_, IOptionPool poolContract) external returns (IOption option);
function createPoolerToken(uint8 decimals_, IOptionPool poolContract) external returns (IPoolerToken poolerToken);
}
| 252,817 | 10,798 |
57216388d9af2a6300889f90d36ca688c2a8391356fbc10935b79339c8cf6c54
| 21,310 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/0c/0c8d365dba11bf0cd2a8809b173901d2b93e7c7f_GothTokenV2.sol
| 3,457 | 13,375 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library SafeMath {
function 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;
}
}
function sqrt(uint256 n) internal pure returns (uint256) { unchecked {
if (n > 0) {
uint256 x = n / 2 + 1;
uint256 y = (x + n / x) / 2;
while (x > y) {
x = y;
y = (x + n / x) / 2;
}
return x;
}
return 0;
} }
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
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);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// GOTH v2 signifies a true growth, the contraints of GOTH v1 were too much.
// With this new and improved version we have more control over the supply and how
// and where it is used. There is a built in swap function that will be active for
// 1 year, and it will allow GOTH v1 holders to, SHAZAM, convert it for GOTH v2.
// The max supply has been reduced from 1 trillion to 1 billion and awards those
// that swap to GOTH v2 a 10% increase on what they receive.
contract GothTokenV2 is Ownable, IERC20, IERC20Metadata, ReentrancyGuard
{
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
uint256 private _maxSupply = 1_000_000_000e18;
string private _name;
string private _symbol;
IERC20 public immutable GOTHV1;
uint256 private swapPeriodEnd;
event SwapOldGOTH(address account, uint256 oldGothBurnt, uint256 newGothMinted);
constructor(IERC20 _gothV1)
{
_name = "GOTH Token v2";
_symbol = "GOTH";
GOTHV1 = _gothV1;
swapPeriodEnd = block.timestamp + 31_540_000;
}
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 maxSupply() public view virtual returns (uint256)
{
return _maxSupply;
}
function balanceOf(address account) public view virtual override returns (uint256)
{
return _balances[account];
}
// Uses nonReentrant modifier to prevent f'ery, checks to see if the sender has the
// required amount of GOTH v1 and checks to see if the time period for swapping has
// not been passed. When both requirements are satisifed it transfers the old GOTH
// from the senders account to a burn address then mints the new GOTH v2 with 10%
// added to the senders address.
function swapOldGOTH (uint256 amount) external nonReentrant
{
require(GOTHV1.balanceOf(msg.sender) >= amount, "swapOldGOTH: not enough old GOTH");
require(block.timestamp < swapPeriodEnd, "swapOldGOTH: the time window for swapping old GOTH to GOTH v2 has ended");
GOTHV1.transferFrom(msg.sender, address(1), amount);
uint256 newAmount = amount.add(amount.div(10)).div(1000);
//uint256 newAmount = amount + amount.div(10);
_mint(msg.sender, newAmount);
emit SwapOldGOTH(msg.sender, amount, newAmount);
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function burn(uint256 amount) public virtual returns (bool)
{
_burn(_msgSender(), 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) public onlyOwner returns (bool)
{
_mint(account, amount);
return true;
}
function _mint(address account, uint256 amount) internal virtual
{
require(account != address(0), "ERC20: mint to the zero address");
require(_maxSupply.sub(_totalSupply) >= amount, "ERC20: max supply reached");
_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 {}
}
| 128,383 | 10,799 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.